Question

我正在尝试使用CRTP为某些部分构建我的程序以摆脱虚函数调用开销但我在类之间的循环引用时遇到问题。

程序基本上有两种主要模式：Hello1和Hello2封装了这个。我想知道是否应该制作一个枚举类Hello {Hello1，Hello2};并使用它来模拟Deriv模板类型的所有内容，我需要使用具体的类？我试着搜索这个，但似乎找不到符合我特定用例的东西（或者至少我不认识）。

template<typename T>
struct Processor
{
    std::vector<T> v_; // holds HelloContainers

    void usage1()
    {
        for (auto& v : v_)
            v->doSomethingToHello();
    }

    void specialize() { /* ... */ }
};

template<> Container<Hello1>::specialize()
{
    // something special for Hello1 only!
}


template<typename Deriv2>
struct HelloContainerBase
{
    void needsAccessFromHello1And2();

    // a whole bunch of other things that Hello{1,2} need access to
    // ..
};

template<typename T>
struct HelloContainer : public HelloContainerBase<HelloContainer<T>>
{
    void doSomethingToHello() { hello_->func2(); }
    void callFunc1() { hello_->func1(); } // <--- slow?

    void needsAccessFromHello()
    T* hello_; // needs
};


struct HelloBase
{
    virtual void func1() = 0;
};

template<typename Deriv>
struct HelloCRTP : public HelloBase
{
    void func2()
    {
        static_cast<Deriv>(this)->func2impl();
    }

    HelloContainer<Deriv>* proc_;
};

struct Hello1 : public HelloCRTP<Hello1>
{
    void func1(); // hopefully no virtual method overhead?
    void func2impl(); // no virtual method overhead

    // ...
};

struct Hello2 : public HelloCRTP<Hello1>
{
    void func1(); // hopefully no virtual method overhead?
    void func2impl(); // no virtual method overhead

    // ...
};

int main()
{

    auto hc1 = new HelloContainer<Hello1>();
    auto proc = new Processor<Hello1>
    proc.v_.push_back(hc1);

    proc.usage();
    proc.specialize();

    hc1->doSomethingToHello();

}

无法突破CRTP周期性参考

0 个答案: