是否可以使用指向未实例化对象的指针作为C ++中的变量？

CiaranWelsh 发表于 Dev

西亚兰·威尔士

我希望C ++类中的属性是特定类的未实例化的类。然后，此类的所有成员都将实现相同的方法，这意味着我可以实例化该对象，然后在情况需要时使用该方法。这是一些代码（未编译），说明了我的意思：


#include <iostream>

using namespace std;

class Event {
public:
    Event() = default;
    virtual void go() = 0;
};

class EventA : Event {
public:
    EventA() = default;

    void go(){
        cout << "Running event A"<< endl;
    }
};

class EventB : Event {
public:
    EventB() = default;


    void go(){
        cout << "Running event B"<< endl;
    }
};

class Situation{
private:
    Event* current_event = &EventA;   //Problematic code: EventA does not refer to a value
public:
    Situation() = default;

    void setEvent(Event* event){
        current_event = event;
    }

    void runEvent(){
        current_event.go();
    }
};

int main() {

    Situation situation;
    situation.runEvent();
    situation.setEvent(&EventB);
    situation.runEvent();

    return 0;
};

吕韦拉

在两个地方，您似乎正在做可以描述为试图从类型中获取指针的操作：

Event* current_event = &EventA;

和

situation.setEvent(&EventB);

这是行不通的，在C ++中并不是真正意义上的东西。我想的可以通过3种不同的方式来实现。

方法1：您可以拥有一个函数指针，然后将函数指针作为参数传递：

#include <iostream>

using namespace std;

void eventA_go(){
    cout << "Running event A"<< endl;
}

void eventB_go(){
    cout << "Running event B"<< endl;
}

class Situation{
private:
    using EventFunctionPtr = void (*)();
    EventFunctionPtr current_event = &eventA_go;
public:
    Situation() = default;

    void setEvent(EventFunctionPtr event){
        current_event = event;
    }

    void runEvent(){
        current_event();
    }
};

int main() {

    Situation situation;
    situation.runEvent();
    situation.setEvent(&eventB_go);
    situation.runEvent();

    return 0;
};

方法2：您可以通过允许类中的任何类型的可调用Situation项（不仅是函数指针），使此代码更通用一些：

#include <iostream>
#include <functional>

using namespace std;

void eventA_go(){
    cout << "Running event A"<< endl;
}

void eventB_go(){
    cout << "Running event B"<< endl;
}

class Situation{
private:
    std::function<void ()> current_event = eventA_go;
public:
    Situation() = default;

    template <typename F>
    void setEvent(F&& event){
        current_event = event;
    }

    void runEvent(){
        current_event();
    }
};

int main() {

    Situation situation;
    situation.runEvent();
    situation.setEvent(&eventB_go);
    situation.runEvent();

    return 0;
};

方法3：您可以回到最初的想法，即必须实现一个基类才能提供go()方法，但是在这种情况下，您实际上必须确保所调用的对象确实存在。一种可能的方法是std::unique_ptr：

#include <iostream>
#include <memory>

using namespace std;

class Event {
public:
    Event() = default;
    virtual ~Event() = default;
    virtual void go() = 0;
};

class EventA : public Event {
public:
    EventA() = default;

    void go(){
        cout << "Running event A"<< endl;
    }
};

class EventB : public Event {
public:
    EventB() = default;

    void go(){
        cout << "Running event B"<< endl;
    }
};

class Situation{
private:
    std::unique_ptr<Event> current_event = std::make_unique<EventA>();
public:
    Situation() = default;

    void setEvent(std::unique_ptr<Event>&& event){
        current_event = std::move(event);
    }

    void runEvent(){
        current_event->go();
    }
};

int main() {

    Situation situation;
    situation.runEvent();
    situation.setEvent(std::make_unique<EventB>());
    situation.runEvent();

    return 0;
};

请注意，在这种情况下，抽象类的析构函数必须是virtual，继承必须是公共的。

本文收集自互联网，转载请注明来源。

如有侵权，请联系[email protected] 删除。