如何设计允许子类返回协变类型的可重写值返回工厂方法？

你需要实现父类的工厂方法按值返回，同时允许子类重写该方法返回自身类型，避免堆分配和指针/引用，保持const-safe。现有父类Point的flip_x/flip_y按值返回Point，子类Point3D重写时因C++值类型不支持协变返回而报错。

问题根源 #

C++的协变返回类型仅支持指针和引用，值类型无法实现协变——因为按值返回子类对象到父类类型会发生切片，且编译器不允许重写方法的返回值类型与父类不一致。

方案一：静态多态（CRTP） #

通过CRTP（奇特递归模板模式）实现静态绑定的协变返回，完全避免动态多态的限制，同时保持按值返回和const-safe：

// 可选：抽象基类，用于统一接口（如果需要动态多态场景）
class PointBase {
public:
    virtual ~PointBase() = default;
    virtual double get_x() const = 0;
    virtual double get_y() const = 0;
};

// CRTP模板类，实现flip的默认逻辑
template<typename Derived>
class PointCRTP : public PointBase {
protected:
    double x, y;
    PointCRTP(double xpos, double ypos) : x(xpos), y(ypos) {}
public:
    double get_x() const override { return x; }
    double get_y() const override { return y; }

    // 返回子类类型，静态绑定
    Derived flip_x() const {
        return Derived{x, -y};
    }

    Derived flip_y() const {
        return Derived{-x, y};
    }
};

// 2D Point类，继承CRTP并指定自身为模板参数
class Point : public PointCRTP<Point> {
public:
    Point() : PointCRTP(0, 0) {}
    Point(double xpos, double ypos) : PointCRTP(xpos, ypos) {}
};

// 3D Point类，继承CRTP并指定自身为模板参数
class Point3D : public PointCRTP<Point3D> {
    double z;
public:
    Point3D() : PointCRTP(0, 0), z(0) {}
    Point3D(double xpos, double ypos, double zpos) : PointCRTP(xpos, ypos), z(zpos) {}
    
    double get_z() const { return z; }

    // 重写flip_x，自定义3D逻辑
    Point3D flip_x() const {
        return Point3D{x, -y, -z};
    }

    Point3D flip_y() const {
        return Point3D{-x, y, -z};
    }

    Point3D flip_z() const {
        return Point3D{-x, -y, z};
    }
};

优点：

• 完全按值返回，无堆分配，效率高
• 静态绑定避免了虚函数开销
• 子类可以自然返回自身类型，无切片问题

缺点：

• 失去动态多态的灵活性（无法通过基类指针调用并获取子类对象）

方案二：隐藏父类方法+重写虚方法 #

如果需要保留原父类的结构和动态多态特性，可在子类中新增同名非虚方法返回自身类型，同时重写父类虚方法以兼容动态调用：

// 原Point类保持不变
class Point
{
    double x, y;

public:
    Point() : Point(0, 0) {}
    Point(double xpos, double ypos) : x{xpos}, y{ypos} {}

    double get_x() const { return x; }
    double get_y() const { return y; }

    virtual Point flip_x() const
    {
        return Point{x, -y};
    }

    virtual Point flip_y() const
    {
        return Point{-x, y};
    }
};

class Point3D : public Point
{
    double z;

public:
    Point3D() : Point3D(0, 0, 0) {}
    Point3D(double xpos, double ypos, double zpos)
    : Point(xpos, ypos), z{zpos} {}

    double get_z() const { return z; }

    // 新增非虚方法，返回Point3D，隐藏父类的flip_x
    Point3D flip_x() const
    {
        return Point3D{get_x(), -get_y(), -z};
    }

    Point3D flip_y() const
    {
        return Point3D{-get_x(), get_y(), -z};
    }
    
    // 重写父类虚方法，确保动态调用时返回Point（切片）
    Point flip_x() const override
    {
        return this->flip_x(); // 调用子类非虚方法，切片为Point
    }

    Point flip_y() const override
    {
        return this->flip_y();
    }

    Point3D flip_z() const
    {
        return Point3D{-get_x(), -get_y(), z};
    }
};

优点：

• 完全保留原父类结构，兼容现有代码
• 静态调用子类对象时返回Point3D，符合需求
• 动态调用（基类指针/引用）时返回Point，保持父类行为一致性

缺点：

• 动态调用时会发生切片，无法获取子类的z坐标数据
• 需要维护两套方法（非虚方法+重写的虚方法）

方案选择 #

如果你的代码场景以静态类型调用为主（如示例中的const Point3D p3{2,2,2}; const Point3D flipped3 = p3.flip_x();），两种方案都能满足需求，无需使用指针或堆分配。若需要动态多态且保留子类数据，才考虑使用智能指针（如std::unique_ptr<Point>）进行堆分配，但会增加内存管理复杂度。

内容的提问来源于stack exchange，提问作者Lily-Heather Crawford