保护 CRTP 模式免受“纯虚拟”调用中的堆栈溢出

Question

考虑以下标准 CRTP 示例：

#include <iostream>

template<class Derived>
struct Base {
    void f() { static_cast<Derived *>(this)->f(); }
    void g() { static_cast<Derived *>(this)->g(); }
};

struct Foo : public Base<Foo> {
    void f() { std::cout << 42 << std::endl; }
};

int main() {
    Foo foo;
    foo.f(); // just OK
    foo.g(); // this will stack overflow and segfault
}

如果这是常规的虚拟继承，我可以将虚拟 f 和 g 方法标记为纯类似

struct Base {
    virtual void f() = 0;
    virtual void g() = 0;
};

并得到一个关于 Foo 是抽象的编译时错误。但是 CRTP 没有提供这样的保护。我可以以某种方式实现它吗？运行时检查也是可以接受的。我考虑过将this->f 指针与static_cast<Derived *>(this)->f 进行比较，但没能成功。

Answer 1

你可以在编译时断言两个指向成员函数的指针是不同的，例如：

template<class Derived>
struct Base {
    void g() {
        static_assert(&Derived::g != &Base<Derived>::g,
                      "Derived classes must implement g()."); 
        static_cast<Derived *>(this)->g(); 
    }
};

Answer 2

这是另一种可能性：

#include <iostream>

template<class Derived>
struct Base {
    auto f() { return static_cast<Derived *>(this)->f(); }
    auto g() { return static_cast<Derived *>(this)->g(); }
};

struct Foo : public Base<Foo> {
    void f() { std::cout << 42 << std::endl; }
};

int main() {
    Foo foo;
    foo.f(); // just OK
    foo.g(); // this will not compile
}

对于 GCC，它给出了一个非常清晰的错误消息（“错误：在扣除 'auto' 之前使用 'auto Base::g() [with Derived = Foo]'”），而对于 Clang，它给出了一个可读性稍差的无限递归模板实例化 Base<Foo>::g，g 实例化自身，但最终以错误结束。

Answer 3

你可以使用这个解决方案，你可以拥有纯“非虚抽象”函数，并且它尽可能映射到 CRTP 这个recommendation of H. Sutter:

template<class Derived>
struct Base
  {
  void f(){static_cast<Derived*>(this)->do_f();}
  void g(){static_cast<Derived*>(this)->do_g();}

  private:
  //Derived must implement do_f
  void do_f()=delete;
  //do_g as a default implementation
  void do_g(){}
  };

struct derived
  :Base<derived>
  {
  friend struct Base<derived>;

  private:
  void do_f(){}
  };

Answer 4

你可以考虑做这样的事情。您可以将 Derived 设为成员，并在每次实例化 Base 时直接将其作为模板参数提供，或者像我在此示例中所做的那样使用 类型别名：

template<class Derived>
struct Base {
    void f() { d.f(); }
    void g() { d.g(); }
private:
    Derived d;
};

struct FooImpl {
    void f() { std::cout << 42 << std::endl; }
};

using Foo = Base<FooImpl>;

int main() {
    Foo foo;
    foo.f(); // OK
    foo.g(); // compile time error
}

当然Derived 不再是派生的，所以你可以为它取一个更好的名字。