从基类方法返回对派生类的引用

Question

我的任务是实现一个简单的 SVG 生成器。我需要支持圆形、折线和文本。这三者至少有 4 种常用方法： - 设置描边颜色 - 设置填充颜色 - 设置描边宽度 - ToString 主要要求之一是支持链接，例如： 折线{}.SetStrokeColor("white").SetFillColor("black")...

我决定实现一个基类 Element，所有其他类都继承自它。这个想法是有一个类 Document ，它包含添加到文档中的所有元素的向量。 基本方法的示例签名：

// source of trouble
Element &SetStrokeColor(const Color &color) {
    ...
    return *this;
}

我的派生类确实调用了这些方法，但问题是这些方法返回的是对基类 Element 的引用，而不是派生类。

我的问题是是否可以一起用 c++ 实现？？？

Further discussion here

Answer 1

如果您想共享实现并保留类型信息，那么您需要 CRTP：

struct ElementBase { };

template <class Concrete>
struct Element : ElementBase {

    Concrete &setStrokeWidth(int width) {
        // Actual implementation...
        (void) width;

        return cthis();
    }

private:
    friend Concrete;
    Element() = default;

    Concrete &cthis() { return static_cast<Concrete &>(*this); }
    Concrete &cthis() const { return static_cast<Concrete const &>(*this); }
};

struct Circle : Element<Circle> {
    Circle &SetCircleCenter(int x, int y) {
        // Actual implementation...
        (void) x;
        (void) y;

        return *this;
    }
};

int main() {
    Circle c;
    c.setStrokeWidth(4).SetCircleCenter(0, 0);
}

See it live on Wandbox

Answer 2

使用协变返回类型，您可以

class Element {
  public:
    // ...

    virtual Element& refToThis() { return *this; };
};

在派生类中

class Derived : public Element {
  public:
    // ...

    Derived& refToThis() override { return *this; };
};

当静态类型为 Derived（例如在 Derived 自身内部）时，它可以让您将 Derived 实例作为 Derived 实例处理。当静态类型为Element时，refToThis()的返回类型也是。

Answer 3

比较：

class Base {};
class Derived : public Base {};

Derived d;
Base* p = &d; // points to a Base that in reality is a derived
Base& b =  d; // in this respect, references do not differ...

// and you can get the original type back:
auto dr = static_cast<Derived&>(b);  // if you know 100% for sure that b is a Derived
auto dp = dynamic_cast<Derived*>(p); // if p might point to another type; you get
                                     // a null pointer back, if it does

返回指向this/*this 的指针或引用绝对没有区别，所以是的，您可以安全地这样做。

编辑：

Circle().SetStrokeWidth(16).SetCircleCenter({0, 0})。 SetStrokeWidth 返回对 Element 的引用，因此 SetCircleCenter 不可用。

不过，在这种情况下，您会遇到一些麻烦。就像lubgr denoted 一样，您可以通过覆盖协变返回类型来解决问题——是的，这意味着您必须分别覆盖每个函数。或者，您可以使用 CRTP 保存所有这些方法：

template <typename T>
class SomeAppropriateName : public Element
{
public:
    T& setStrokeWidth(unsigned int width)
    {
        Element::setStrokeWidth(width);
        return static_cast<T&>(*this);
    }
};

class Circle : public SomeAppropriateName<Circle>
{
    // the overrides needed are inherited...
};

对于这种方法，来自Element 类的原始函数需要是非虚拟的（实际上是一个优势，因为虚拟函数调用的成本更高......）；在模板中，参数（T，即Circle）尚未完全定义（使用 CRTP 模式），编译器将无法检查返回类型是否真的是协变的。所以实际上，我们只是遮蔽了基类的函数。

与覆盖相比，这仍然没有缺点：只有在对象上直接调用（虚拟）函数时，协变返回类型才可用：

Circle c;
c.setStrokeWidth(7).setCenter();

Element& e = c;
e.setStrokeWidth(7).setCenter(); // fails, even if you implement co-variant override directly