我有一个多态类的层次结构，比如 Shape 抽象基类及其派生类，例如Rectangle、Circle 等。在 Virtual Constructor Idiom 之后，我想知道为什么在使用智能指针时，派生类中的虚构造函数的返回类型应该返回与其父类相同的类型？
例如，看下面的代码，其中 clone() 和 create() 成员函数需要返回 smart_pointers 到 Shape 类。但是，当使用简单指针时，返回类型可以与派生类的类型相同。
谁能解释为什么我们需要以引用的方式处理这些功能？

class Shape;

typedef std::unique_ptr<Shape> shape_ptr;

class Shape{

    public:

        //typedef std::unique_ptr<Shape> shape_ptr;

        Shape(){};
        virtual ~Shape(){};

        virtual void draw() const = 0;
        virtual float area() const = 0;

        virtual shape_ptr clone() const = 0;
        virtual shape_ptr create() const = 0;
        //virtual Shape*clone() const = 0;
        //virtual Shape*create() const = 0;
};

class Rectangle:public Shape{
    public:

        typedef std::unique_ptr<Rectangle> rectangle_SmartPtr;

        Rectangle(int height=0, int width=0):m_Height(height),m_Width(width){};
        Rectangle(const Rectangle & rect):m_Height(rect.m_Height),m_Width(rect.m_Width){};
        ~Rectangle(){};

        virtual void draw() const;
        virtual float area() const;

        //virtual rectangle_SmartPtr clone() const{ return rectangle_SmartPtr(new Rectangle(*this)); };
        // error C2555: 'Rectangle::clone': overriding virtual function return type differs and is not covariant from 'Shape::clone'
        //virtual rectangle_SmartPtr create() const{ return rectangle_SmartPtr(new Rectangle()); };
        // error C2555: 'Rectangle::create': overriding virtual function return type differs and is not covariant from 'Shape::create'

        virtual shape_ptr clone() const{ return shape_ptr(new Rectangle(*this)); }; //OK
        virtual shape_ptr create() const{ return shape_ptr(new Rectangle()); }; //OK

        //virtual Rectangle* clone() const{ return new Rectangle(*this); }; //OK
        //virtual Rectangle* create() const{ return new Rectangle(); }; //OK

    private:
        int m_Height;
        int m_Width;
};


class Circle:public Shape{
    public:

        typedef std::unique_ptr<Circle> circle_SmartPtr;

        Circle(float radius=0):m_Radius(radius){};
        Circle(const Circle & other):m_Radius(other.m_Radius){};
        ~Circle(){std::cout << "Circle destructor: " << this << std::endl; };

        virtual void draw() const;
        virtual float area() const;

        //virtual circle_SmartPtr clone() const{ return circle_SmartPtr(new Circle(*this)); };
        // error C2555: 'Circle::clone': overriding virtual function return type differs and is not covariant from 'Shape::clone'
        //virtual circle_SmartPtr create() const{ return circle_SmartPtr(new Circle()); }; 
        //  error C2555: 'Circle::create': overriding virtual function return type differs and is not covariant from 'Shape::create'

        virtual shape_ptr clone() const{ return shape_ptr(new Circle(*this)); }; //OK
        virtual shape_ptr create() const{ return shape_ptr(new Circle()); }; //OK

        //virtual Circle* clone() const{ return new Circle(*this); }; //OK
        //virtual Circle* create() const{ return new Circle(); }; //OK

    private:

        float m_Radius;
};

最佳答案

这称为协方差。

在类层次结构中，当基类指定返回 T* 的虚方法时或 T& , 然后允许派生类返回 U*或 U& ，分别提供U源自 T (注意:显然是 const 和 volatile 的组合)。

这是一个特殊的规则，由编译器检查，它有效，因为如果 U源自 T然后是U*可以转换为 T* .不幸的是，该规则的局限性在于它不适用于任何转换，因此即使您通常可以构造一个 unique_ptr<Shape>来自unique_ptr<Rectangle> ...协方差不起作用。

这就是为什么在其 Cloneable 概念中，Boost 要求返回一个裸 指针类型。很遗憾，但这是获得协方差的唯一方法。

关于c++ - 具有智能指针的虚拟构造函数习语，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/8870489/