c ++多态性和传递子类

Question

我正在研究 C++ 中的继承，并尝试实现一个基本设置，其中 基类具有 a) 子类必须实现的抽象方法 fire() 和 b) 子类继承的变量 someDouble。

我当前的设置如下。这不会编译，因为getDerivedObject() 正试图返回一个抽象类。 （请注意，如果可能的话，为了安全起见，我宁愿保留 BaseClass 抽象。）

我尝试过的另一种方法是让 AnotherClass 返回一个指向对象的指针 - 但这也不适用于 object 超出范围时将被删除。

这是正确的整体方法吗？我可以从AnotherClass 返回什么，这将允许我从BaseClass 和fire() 从DerivedClass 访问getSomeDouble()？

class BaseClass{
public:
    virtual void fire() = 0;
    // Use a getter and setter as you can't make a variable virtual in c++
    virtual double getSomeDouble(){ return someDouble; }
    virtual void setSomeDouble(double d){ someDouble = d; }

private:
    double someDouble;
};

class DerivedClass : public BaseClass{
public:
    void fire(){ cout << "Derived class fired. Yay." << endl; }
};


class AnotherClass{
public:
    // Set up a DerivedClass object and set someDouble to 1
    BaseClass getDerivedObject(){ // currrently fails; can't return an abstract class
        DerivedClass object;
        object.setSomeDouble(1);
        return object; // I will later want this to return vector<BaseClass> or similar
    };
};


int main()
{
    AnotherClass t;
    BaseClass o = t.getDerivedObject();
    BaseClass * p = &o;

    cout << to_string( (*p).getSomeDouble() );
    (*p).fire();
    return 0;
}

编辑：我尝试过使用这样的指针，但是当对象离开范围时，当然会被删除：

BaseClass * getDerivedObject(){
        DerivedClass object;
        object.setSomeDouble(1);
        BaseClass * p = &object;
        return p;
    };

Answer 1

使用unique_ptrs 对多态对象进行伪常规访问。

template<class T>
using up=std::unique_ptr<T>;

// comes free in C++14
template<class T, class...Args>
up<T> make_unique( Args&&...args ) {
  return up<T>( new T(std::forward<Args>(args)...) );
}

up<BaseClass> getDerivedObject(){ // currrently fails; can't return an abstract class
    up<DerivedClass> object = make_unique<DerivedClass>();
    object->setSomeDouble(1);
    return object;
};

稍后：

up<BaseClass> o = t.getDerivedObject();

std::cout << to_string( o->getSomeDouble() );
o->fire();

这假设 C++11。现在是 2015 年，这似乎很安全。

使用up<T> 和make_unique<T> 和std::vector< up<T> > 意味着几乎不需要调用new。使用原始指针非常容易出错，这可以避免这种情况，同时仍然为您提供动态多态性。