用CRTP替换非纯虚拟函数

Replacing non-pure virtual functions with CRTP

本文关键字：虚拟 函数 CRTP 替换      更新时间：2023-10-16

我正在通过C++SDK为应用程序编写插件。机制相当简单。插件通过预定义的接口提供其功能。这是通过让服务器类从每个接口的一个实现类继承来实现的，该接口包含纯vitual函数或具有默认实现的非纯函数
这是非常实用的，因为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关键字。但是编译器不会检查函数签名是否匹配
这种情况有什么众所周知的模式吗？我所问的可能吗？

（请用小字，因为我对模板的专业知识有点肤浅。谢谢。）

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

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来消除虚拟调用开销。我不知道当函数保持为virtual时，CRTP是否有任何性能优势。

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

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设计
  • 有关基于政策的设计的更多信息，您可以观看视频或阅读Andrei Alexandrescu的书籍/文章

老实说，我不确定我会使用以下代码，但我认为它符合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习惯用法设计的。

我知道，成员检测器类远不是很好
不管怎样，这就足够了，所以…

我相信，我理解你的意图。如果我的理解是正确的，那就不可能做到。

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

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

相关文章：