用 CRTP 替换非纯虚函数

Question

我正在通过其 C++ SDK 为应用程序编写插件。机制相当简单。插件通过预定义的接口提供其功能。这是通过让服务器类从每个接口的一个实现类继承来完成的，该实现类包含纯虚拟函数或具有默认实现的非纯函数。
这是非常实用的，因为 SDK 客户端只需覆盖插件所需的那些方法和/或为（罕见的）那些没有默认值的方法提供实现。

困扰我的是，在编译时一切都是已知的。与运行时多态性相关的虚函数表和机器在这里只是为了提供默认实现。
我试图在保持便利的同时消除这种开销。

作为一个（非常人为的）示例，假设我有几个服务器提供一个接口（名为 Blah），该接口仅由一个方法组成，没有默认实现。

// SDK header
struct OldImpl_Blah {
    virtual ~OldImpl_Blah() =default;
    virtual int mult(int) =0;
};

// plugin source
class OldServer3 : public OldImpl_Blah {
public:
    int mult(int i) override { return 3 * i; }
};

class OldServer5 : public OldImpl_Blah {
public:
    int mult(int i) override { return 5 * i; }
};

对于纯虚函数，直接 CRTP 就可以了。

// SDK header
template <typename T>
struct NewImpl_Blah {
    int mult(int i) { return static_cast<T*>(this)->mult(i); }
};

// plugin source
class NewServer3 : public NewImpl_Blah<NewServer3> {
public:
    int mult(int i) { return 3 * i; }
};

class NewServer5 : public NewImpl_Blah<NewServer5> {
public:
    int mult(int i) { return 5 * i; }
};

问题在于非纯虚函数，即当方法有默认实现时。

// SDK header
struct OldImpl_Blah {
    virtual ~OldImpl_Blah() =default;
    virtual int mult(int i) { return i; }    // default
};

// plugin source
class OldServer3 : public OldImpl_Blah {
public:
    int mult(int i) override { return 3 * i; }
};

class OldServer5 : public OldImpl_Blah {
public:
    int mult(int i) override { return 5 * i; }
};

我尝试将 CRTP 与一些表达式 SFINAE 技巧结合起来，但失败了。
我想我需要的是某种代码调度，其中基类要么提供默认实现，要么将其参数转发给派生类中的实现（如果存在）。
问题似乎是调度应该依赖于基类中编译器尚不可用的信息。

一个简单的解决方案是删除代码中的virtual 和override 关键字。但是编译器不会检查函数签名是否匹配。
这种情况有一些众所周知的模式吗？我要问的有可能吗？

（请使用小字，因为我在模板方面的专业知识有点轻。谢谢。）

Answer 1

与往常一样，另一种间​​接层级是解决方案。在这种特殊情况下，公共非虚拟函数调用私有或受保护的虚拟函数是众所周知的技术。它有自己的用途，与这里讨论的内容无关，所以无论如何都要检查一下。通常它是这样工作的：

struct OldImpl_Blah {
piblic:
    virtual ~OldImpl_Blah() = default;
    int mult(int i) { return mult_impl(i); }
protected:
    virtual int mult_impl(int i) { return i; }
};

// plugin source
class OldServer3 : public OldImpl_Blah {
protected:
    int mult_impl(int i) override { return 3 * i; }
};

CRTP 完全一样：

template <class T>
struct OldImpl_Blah {
piblic:
    virtual ~OldImpl_Blah() = default;
    int mult(int i) { return static_cast<T*>(this)->mult_impl(i); }
protected:
    virtual int mult_impl(int i) { return i; }
};

// plugin source
class OldServer3 : public OldImpl_Blah<OldServer3> {
protected:
    int mult_impl(int i) override { return 3 * i; }
};

免责声明：据说 CRTP 通过 nit 要求函数为 virtual 来消除虚拟调用开销。我不知道 CRTP 在保留函数时是否有任何性能优势virtual。

Answer 2

考虑使用策略设计之类的东西：

struct DefaultMult {
    int mult(int i) { return i; }
};

// SDK header
template <typename MultPolicy = DefaultMult>
struct NewImpl_Blah {
    int mult(int i) { return multPolicy.mult(i); }
  private:
    MultPolicy multPolicy;
};

// plugin source
class NewServer3 {
public:
    int mult(int i) { return 3 * i; }
};

class NewServer5 {
public:
    int mult(int i) { return 5 * i; }
};

void client() {
  NewImpl_Blah<NewServer5> myServer;
}

还请注意，理论上使用 final 关键字和 override 可以使编译器比 vtable 方法更优化地调度。如果您在第一个实现中使用 final 关键字，我希望现代编译器能够进行优化。

一些有用的参考：

• mixin design
• 有关基于策略的设计的更多信息，您可以观看视频或阅读 Andrei Alexandrescu 的书籍/文章

Answer 3

老实说，我不确定我是否会使用以下代码，但我认为它可以满足 OP 的要求。
这是一个最小的工作示例：

#include<iostream>
#include<utility>

template<class D>
struct B {
    template <typename T>
    struct hasFoo {
        template<typename C>
        static std::true_type check(decltype(&C::foo));

        template<typename>
        static std::false_type check(...);

        static const bool value = decltype(check<T>(0))::value;
    };

    int foo() {
        return B::foo<D>(0, this);
    }

private:
    template<class T>
    static auto foo(int, B* p) -> typename std::enable_if<hasFoo<T>::value, int>::type {
        std::cout << "D::foo" << std::endl;
        return static_cast<T*>(p)->foo();
    }

    template<class T>
    static auto foo(char, B*) -> typename std::enable_if<not hasFoo<T>::value, int>::type {
        std::cout << "B::foo" << std::endl;
        return 42;
    }
};

struct A: B<A> { };

struct C: B<C> {
    int foo() {
        std::cout << "C::foo" << std::endl;
        return 0;
    }
};

int main() {
    A a;
    a.foo();
    std::cout << "---" << std::endl;
    B<A> *ba = new A;
    ba->foo();
    std::cout << "---" << std::endl;
    C c;
    c.foo();
    std::cout << "---" << std::endl;
    B<C> *bc = new C;
    bc->foo();
}

如果我做对了，就不会有虚方法，但会调用foo 的正确实现，无论您使用的是基类还是派生类。
当然，它是围绕 CRTP 习语设计的。

我知道，成员检测器类远非好。
无论如何，对于问题的目的来说已经足够了，所以......

Answer 4

我相信，我明白你想要做什么。如果我的理解是正确的，那是做不到的。

从逻辑上讲，您可能希望在Base 中有mult 以检查子结构中是否存在mult - 如果存在，则调用它，如果不存在，则提供一些默认实现。这里的缺陷是子类中总是有mult - 因为它会从Base 继承检查mult 的实现。不可避免。

解决方案是在子类中以不同的方式命名函数，并在基类中检查是否存在不同命名的函数 - 并调用它。这是一件简单的事情，如果你喜欢这个例子，请告诉我。但是，当然，您会在这里失去覆盖的美感。