CRTP 中未实现的派生函数

Question

我正在制作一个包装器，以便能够轻松地将未来的代码移植到不同的后端渲染引擎。我们目前在 GDI 工作。目前我正在抽象后端上实现虚函数，但我想将其更改为 CRTP，因为后端应该在编译时已知。

不幸的是，我在使用 CRTP（第一次使用）时遇到的一个问题是我必须实现派生函数的所有细节。相反，抽象实现不需要完全实现的派生子级。为了证明这一点：

#include <Windows.h>
#include <iostream>

struct AbstractBackend
{
  virtual ~AbstractBackend() = 0;

  virtual void foo()
  {
    throw "implementation missing: failed to override in derived class";
  }

  virtual void bar()
  {
    throw "implementation missing: failed to override in derived class";
  }
};

AbstractBackend::~AbstractBackend() {}

struct ConcreteBackendA : AbstractBackend
{
  int backendResource;

  ConcreteBackendA(int rsc) :
    backendResource(rsc)
  {}

  virtual void foo()
  {
    printf("executing ConcreteBackendA::foo!\n");
  }

  // ConcreteBackendA does not support "bar" feature
};

struct ConcreteBackendB : AbstractBackend
{
  HDC backendResource;

  ConcreteBackendB(HDC hdc) :
    backendResource(hdc)
  {}

  virtual void foo()
  {
    printf("executing ConcreteBackendB::foo!\n");
  }

  virtual void bar()
  {
    printf("executing ConcreteBackendB::bar!\n");
  }

};

struct FrontEnd
{
  AbstractBackend *backend;

  FrontEnd(int rsc) :
    backend(new ConcreteBackendA(rsc))
  {}

  FrontEnd(HDC hdc) :
    backend(new ConcreteBackendB(hdc))
  {}

  ~FrontEnd()
  {
    delete backend;
  }

  void foo()
  {
    backend->foo();
  }

  void bar()
  {
    backend->bar();
  }
};

int main()
{
  int rsc = 0;
  HDC hdc = 0;
  FrontEnd A(rsc);
  FrontEnd B(hdc);

  A.foo();
  A.bar(); // throws an error, A::bar is not a feature of this engine

  B.foo();
  B.bar();

  std::cin.get();
}

在此示例中，AbstractBackend 支持两个功能，foo 和 bar。 ConcreteBackendA只支持foo，bar是它不支持的功能（可能是Draw3dText之类的），不过没关系。用户可以捕获异常并继续。一个小缺点是虚函数的使用。我想像这样使用 CRTP 的想法：

#include <Windows.h>
#include <iostream>

template <class Derived>
struct AbstractBackend
{
  virtual ~AbstractBackend() = 0;

  void foo()
  {
    static_cast<Derived*>(this)->foo();
  }

  void bar()
  {
    static_cast<Derived*>(this)->bar();
  }
};

template <class Derived>
AbstractBackend<Derived>::~AbstractBackend() {}

struct ConcreteBackendA : AbstractBackend<ConcreteBackendA>
{
  int backendResource;

  ConcreteBackendA(int rsc) :
    backendResource(rsc)
  {}

  void foo()
  {
    printf("executing ConcreteBackendA::foo!\n");
  }

  // ConcreteBackendA does not support "bar" feature
};

struct ConcreteBackendB : AbstractBackend<ConcreteBackendB>
{
  HDC backendResource;

  ConcreteBackendB(HDC hdc) :
    backendResource(hdc)
  {}

  void foo()
  {
    printf("executing ConcreteBackendB::foo!\n");
  }

  void bar()
  {
    printf("executing ConcreteBackendB::bar!\n");
  }
};

template <class ConcreteBackend>
struct FrontEnd
{
  AbstractBackend<ConcreteBackend> *backend;

  FrontEnd(int rsc) :
    backend(new ConcreteBackendA(rsc))
  {}

  FrontEnd(HDC hdc) :
    backend(new ConcreteBackendB(hdc))
  {}

  ~FrontEnd()
  {
    delete backend;
  }

  void foo()
  {
    backend->foo();
  }

  void bar()
  {
    backend->bar();
  }
};

int main()
{
  int rsc = 0;
  HDC hdc = 0;
  FrontEnd<ConcreteBackendA> A(rsc);
  FrontEnd<ConcreteBackendB> B(hdc);

  A.foo();
  A.bar(); // no implementation: stack overflow

  B.foo();
  B.bar();

  std::cin.get();
}

问题是，如果派生的class无法从AbstractBackend实现一个函数，那么AbstractBackend将调用自身导致堆栈溢出。

如何使用 CRTP 复制虚拟抽象实现的行为？

Answer 1

你在滥用面向对象编程。

在语义上，AbstractBackend 是一个接口：一个契约。如果 class Alice 继承自 AbstractBackend，那么 Alice 就是 AbstractBackend。不是部分 AbstractBackend。完全 AbstractBackend。这是 Liskov's substitution principle (the L of SOLID).

如果 classes Bob 和 Charlie 部分实施 AbstractBackend，这意味着您确实有 两个合同 ：Interface1 和 Interface2:

Bob 实现（继承）Interface1,
Charlie 实现（继承）Interface2,
Alice 实现（继承）Interface1 和 Interface2.

CRTP又可以用了，你的代码闻起来很新鲜，生活很愉快。祝周末愉快。

Answer 2

template <class Derived>
struct AbstractBackend
{
  virtual ~AbstractBackend() = 0;

  void foo()
  {
    static_cast<Derived*>(this)->foo_impl();
  }

  void bar()
  {
    static_cast<Derived*>(this)->bar_impl();
  }

  void foo_impl()
  {
    throw "implementation missing: failed to override in derived class";
  }

  void bar_impl()
  {
    throw "implementation missing: failed to override in derived class";
  }

};

现在您可以使用 foo/bar 的默认实现。

派生类覆盖 foo_impl 而不是 foo。

但是，这种特殊用途是一个糟糕的计划；你在编译时知道给定的 AbstractBackend<D> 是否实现了。

毕竟，我们正在实施编译时 "dynamic" dipatch；为什么不在编译时评估错误？

  void foo_impl() = delete;
  void bar_impl() = delete;

现在，在编译时在您的代码中完成分派的那一刻，您会得到错误，而不是等到编译时。

CRTP 中未实现的派生函数

Unimplemented derived function in CRTP

c++

oop

abstract

crtp

c++11