Question

TL / DR：是否有（更方便）的方式来实现此类功能？

我必须为通过引用base表示的class-type和class-instance调用相同的静态代码：

int main()
{
    // Invokes on class
    bar<C1>(); // invokes C1::foo()
    bar<C2>(); // invokes C2::foo()

    // Invokes on instance
    bar(C1()); // invokes C1::foo()
    bar(C2()); // invokes C2::foo()
}

但问题是我无法在没有代码重复的情况下实现这一点。对于每个派生类，我必须编写静态和虚拟方法。静态 - 因为我不能在类上调用虚方法，而虚拟调用静态 - 因为除了虚方法之外无法区分对象行为：

template<typename T>
void bar()
{
    T::foo();
}

void bar(A const &r)
{
    r.foo();
}

因此，我的解决方法是解决重复代码的问题：

#include <iostream>

class A
{
public:
    virtual void foo() const = 0;
};

template<typename derived_T>
class B: public A
{
public:
    virtual void foo() const
    {
        derived_T::foo();
    }
};

class C1 : public B<C1>
{
public:
    static void foo()
    {
        std::cout << "C1::foo()" << std::endl;
    }
};

class C2 : public B<C2>
{
public:
    static void foo()
    {
        std::cout << "C2::foo()" << std::endl;
    }
};

这种方法效果很好，但至少有两个不便之处。

首先，我必须引入一个带有实现虚方法的辅助模板类B.

其次，每个继承链（从B到最终类）必须包含使用任何中间类作为指针/引用类型的模板。例如。 A＆lt; -B＆lt; -T1＆lt; -T2＆lt; -C，T1和T2必须是模板类以提供C :: foo（）。

Answer 1

一种可能的解决方案是具有基类注入的CRTP。

template <typename T, typename... Bases> 
struct CRTPFooInjector : Bases... 
{
    virtual void vfoo() { T::foo(); }
};

这是您的注射器模板。它只实现了foo的虚拟版本，没有别的。

struct Base: CRTPFooInjector<Base>
{
    static int foo() { std::cout << "Base::foo()" << std::endl; }
};


struct Der1 : CRTPFooInjector<Der1, Base>
{
    static int foo() { std::cout << "Der1::foo()" << std::endl; }
};


struct Der2 : CRTPFooInjector<Der2, Base>
{
    static int foo() { std::cout << "Der2::foo()" << std::endl; }
};


struct Der12 : CRTPFooInjector<Der12, Der1, Der2>
{
    static int foo() { std::cout << "Der12::foo()" << std::endl; }
};

现在，而不是普通的层次结构Base <- Der1 <- Der12，您的Injector <- Base <- Injector <- Der1 <- Injector <- Der12略有不同，但对于大多数用户来说，这应该是透明的。

如果你需要混合一些虚拟基类：

template <typename T>
struct Virtual : virtual T
{
};

struct Der1 : CRTPFooInjector<Der1, Virtual<Base>> ...

Answer 2

如果你有几个静态方法，你的派生类是固定的，你可以使用访问者模式：

class IAVisitor;
struct A
{
    virtual ~A() = default;
    virtual void accept(IAVisitor& visitor) = 0;
};
struct C1; struct C2; /*..*/; struct Cn;
struct IAVisitor
{
    virtual ~IAVisitor() = default;
    virtual visit(C1&) = 0;
    virtual visit(C2&) = 0;
    //...
    virtual visit(Cn&) = 0;
};

struct C1 : A
{
    void accept(IAVisitor& visitor) override {visitor.visit(*this);};
    static void foo();
};
// Similar code for C2, Cn

template <typename F>
struct AVisitor_F : IAVisitor
{
    AVisitor_F(F f) : f(f) {}
    void visit(C1& a) override { f(a); }
    void visit(C2& a) override { f(a); }
    //...
    void visit(Cn& a) override { f(a); }

    F f;
};

并且

struct FooCaller
{
    template<typename T>
    void operator () (const T&) const
    {
        T::foo();
    }
};

最后：

AVisitor_F<FooCaller> fooVisitor;
a.accept(fooVisitor);

如何实现静态虚拟成员函数

2 个答案: