在此上下文中如何使用 CRTP 删除虚拟方法？

Question

我有以下类似于我的代码库的程序。一个 FunctionState class 执行某种算法（可能在多个线程中），一个 Function class 控制 FunctionState classes 的使用方式，并可能执行一些算法 setup/teardown 操作。

#include <iostream>
#include <vector>

class FunctionState;

class Function {
public:
    virtual FunctionState* NewFunctionState() = 0;

protected:
    std::vector<FunctionState*> states;
};

class FunctionState {
public:
    FunctionState(Function* func) : mFunc(func) {}

    virtual void RunState() = 0;
    void ExecuteFunctionLotsAndLotsOfTimes();

private:
    Function* mFunc;
};

#define VERY_BIG_NUMBER 10

void FunctionState::ExecuteFunctionLotsAndLotsOfTimes() {
    for(int i = 0; i < VERY_BIG_NUMBER; ++i) {
        RunState();
    }
};

class PrintFunction : public Function {
    FunctionState* NewFunctionState();
};

class PrintFunctionState : public FunctionState {
public:
    PrintFunctionState(PrintFunction* func) : FunctionState(func) {}

    void RunState() override {
        std::cout << "in print function state" << '\n';
    }
};

FunctionState* PrintFunction::NewFunctionState() {
    FunctionState* state = new PrintFunctionState(this);
    states.push_back(state);
    return state;
}

class AddFunction : public Function {
    FunctionState* NewFunctionState();
};

class AddFunctionState : public FunctionState {
public:
    AddFunctionState(AddFunction* func) : FunctionState(func), x(0) {}

    void RunState() override {
        ++x;
    }
private:
    int x;
};

FunctionState* AddFunction::NewFunctionState() {
    FunctionState* state = new AddFunctionState(this);
    states.push_back(state);
    return state;
}


int main() {
    Function* func = new PrintFunction();
    Function* func2 = new AddFunction();
    std::vector<Function*> vec = {func, func2};

    for(auto& func : vec) {
        func->NewFunctionState()->ExecuteFunctionLotsAndLotsOfTimes();
    }

    return 0;
}

现在我分析了我的代码，发现 FunctionState::ExecuteFunctionLotsAndLotsOfTimes() 处有一个热点。问题在于此函数循环多次并调用 RunState()，这是 FunctionState class 上的虚函数。在那里，我执行了很多操作，这些操作可能会从 L1 缓存中清除 vtable 指针，导致 L1 缓存错过循环的每次迭代。

所以我想消除虚拟呼叫的需要。我决定使用 CRTP 是一个很好的方法。 FunctionState class 将采用 class 类型的模板参数来实现它并调用它的适当方法，不需要对 RunState() 的虚拟调用。

现在，当我尝试将其移动到 CRTP 时，我运行遇到了函数 class 的一些问题：

如何转发声明 FunctionState class（因为它现在是模板化的）？
我是否也需要向函数 class 添加模板参数？

3。如果我将其模板化，Function 对象的构造会是什么样子？我将如何消除对使用函数对象指定类型参数的 classes 的需要？

请注意，这只是我真实代码库的一个简单版本。真正的代码库是 10K+ 行代码（并非难以管理，但完全重写是不可能的）。

此外，如果有另一种方法可以删除不涉及 CRTP 的对 RunState() 的虚拟调用，那么我们也将不胜感激。

我尝试使用 CRTP：

#include <iostream>
#include <vector>

class Function;

template<class T>
class FunctionState {
public:
    FunctionState(Function* func) : mFunc(func) {}

    void RunState() {
        static_cast<T*>(this)->RunState();
    };

    void ExecuteFunctionLotsAndLotsOfTimes();
private:
    Function* mFunc;
};

class Function {
public:
    virtual FunctionState* NewFunctionState() = 0;

protected:
    std::vector<FunctionState*> states;
};

#define VERY_BIG_NUMBER 10

template <typename T>
void FunctionState<T>::ExecuteFunctionLotsAndLotsOfTimes() {
    for(int i = 0; i < VERY_BIG_NUMBER; ++i) {
        RunState();
    }
};

class PrintFunctionState;
class PrintFunction : public Function {
    PrintFunctionState* NewFunctionState();
};

class PrintFunctionState : public FunctionState<PrintFunctionState> {
public:
    PrintFunctionState(PrintFunction* func) : FunctionState<PrintFunctionState>(func) {}

    void RunState() {
        std::cout << "in print function state" << '\n';
    }
};

PrintFunctionState* PrintFunction::NewFunctionState() {
    PrintFunctionState* state = new PrintFunctionState(this);
    states.push_back(state);
    return state;
}

class AddFunctionState;
class AddFunction : public Function {
    AddFunctionState* NewFunctionState();
};

class AddFunctionState : public FunctionState<AddFunctionState> {
public:
    AddFunctionState(AddFunction* func) : FunctionState<AddFunctionState>(func), x(0) {}

    void RunState() {
        ++x;
    }
private:
    int x;
};

AddFunctionState* AddFunction::NewFunctionState() {
    AddFunctionState* state = new AddFunctionState(this);
    states.push_back(state);
    return state;
}


int main() {
    Function* func = new PrintFunction();
    Function* func2 = new AddFunction();
    std::vector<Function*> vec = {func, func2};

    for(auto& func : vec) {
        func->NewFunctionState()->ExecuteFunctionLotsAndLotsOfTimes();
    }

    return 0;
}

Answer 1

Function 必须有一个非模板类型作为 NewFunctionState 的 return 值，所以你需要一个额外的基础 class

class FunctionStateBase {
    virtual void ExecuteFunctionLotsAndLotsOfTimes() = 0;
    // No void RunState()!
}

template<typename T>
class FunctionState {
    void ExecuteFunctionLotsAndLotsOfTimes();
    // Still no void RunState()!
}

class PrintFunctionState : public FunctionState<PrintFunctionState> {
    void RunState();
}

template <typename T>
void FunctionState<T>::ExecuteFunctionLotsAndLotsOfTimes() {
    for(int i = 0; i < VERY_BIG_NUMBER; ++i) {
        static_cast<T*>(this)->RunState(); // Statically bound!
    }
};

Answer 2

基于类型擦除和 CRTP 的混合解决方案怎么样？
它遵循一个基于问题中的片段的最小工作示例：

#include <iostream>
#include <vector>

class PrintFunctionState;
class AddFunctionState;
class FunctionState;

class Function {
    template<typename T>
    static FunctionState * InternalNewFunctionState(Function *self, std::vector<FunctionState*> &states) {
        FunctionState* state = new T(self);
        states.push_back(state);
        return state;
    }

public:
    template<typename T>
    static Function * create() {
        Function *func = new Function;
        func->internalNewFunctionState = &InternalNewFunctionState<T>;
        return func;
    }

    FunctionState* NewFunctionState() {
        return internalNewFunctionState(this, states);
    }

private:
    FunctionState * (*internalNewFunctionState)(Function *, std::vector<FunctionState*> &);
    std::vector<FunctionState*> states;
};

class FunctionState {
public:
    FunctionState() = default;
    virtual ~FunctionState() = default;
    virtual void ExecuteFunctionLotsAndLotsOfTimes() = 0;
};

template<typename Derived>
class IntermediateFunctionState: public FunctionState {
public:
    IntermediateFunctionState(Function* func) : mFunc(func) {}

    void ExecuteFunctionLotsAndLotsOfTimes() override {
        Derived *self = static_cast<Derived *>(this);
        for(int i = 0; i < 10; ++i) {
            self->RunState();
        }
    }

private:
    Function* mFunc;
};

class PrintFunctionState : public IntermediateFunctionState<PrintFunctionState> {
public:
    PrintFunctionState(Function* func) : IntermediateFunctionState(func) {}

    void RunState() {
        std::cout << "in print function state" << '\n';
    }
};

class AddFunctionState : public IntermediateFunctionState<AddFunctionState> {
public:
    AddFunctionState(Function* func) : IntermediateFunctionState(func), x(0) {}

    void RunState() {
        std::cout << "in add function state" << '\n';
        ++x;
    }

private:
    int x;
};

int main() {
    Function* func = Function::create<PrintFunctionState>();
    Function* func2 = Function::create<AddFunctionState>();
    std::vector<Function*> vec = { func, func2 };

    for(auto& func : vec) {
        func->NewFunctionState()->ExecuteFunctionLotsAndLotsOfTimes();
    }

    return 0;
}

我删除了一些不再需要的类。
希望代码不言自明，如果我可以添加更多详细信息，请在评论中告诉我。

Answer 3

如果我对你的问题的理解正确，这可以通过使用模板链接来解决。这是它如何工作的粗略示例：

#include <iostream>

/*
    Just make print invocations a little less cluttered for our purposes here.
*/
template <typename Type>
void Show(Type value)
{
    std::cout << value << std::endl;
}

/*
    Base class for function types 
*/
template <typename Self>
class Function 
{
    public:

/*
    For the best performance possible, we'll always inline this function.
*/    
    inline void RunState()
    {
        static_cast<Self*>(this)->RunState();
    }

    void ExecuteFunctionLotsAndLotsOfTimes(int iterations = 1)
    {
        for(int i = 0; i < iterations; ++i)
        {
            Show("...Loop...");    
            RunState();
        }    
    }
};

/*
    Everything here is placed in an internal namespace, as none of it will be used by the caller.
*/
namespace Internal_
{

/*
    ChainFunctionLink works like an array of functions. Each of it's members 
    is either some kind of function object or another ChainFunctionLink.
*/    
template <typename First, typename Second>
struct ChainFunctionLink : Function<ChainFunctionLink<First, Second>>
{
    ChainFunctionLink(First first, Second second)
    : first(first), second(second)
    {    }

    inline void RunState()
    {
        first.RunState();
        second.RunState();
    }

    First
        first;
    Second
        second;
};

/*
    We won't be able to explicitly specify the template parameters of ChainFunctionLink 
    later, so a generating function will be needed to deduce them for us. 
*/
template <typename First, typename Second>
ChainFunctionLink<First, Second> MakeChainFunctionLink(First first, Second second)
{
    return ChainFunctionLink<First, Second>(first, second);
}

} // namespace Internal_

/*
    ChainFunction generates ChainFunctionLink's for the caller.
*/
template <typename First, typename Second, typename ...Next>
auto ChainFunction(First first, Second second, Next ...next)
{
    return Internal_::MakeChainFunctionLink(first, ChainFunction(second, next...));
}

/*
    The last link in the chain.
*/
template <typename Last>
Last ChainFunction(Last last)
{
    return last;
}

// Example usage:

class PrintFunction : public Function<PrintFunction>
{
    public:

    inline void RunState()
    {
        Show("PrintFunction::RunState()");
    }    
};

class AddFunction : public Function<AddFunction>
{
    public:

    inline void RunState()
    {
        Show("AddFunction::RunState()");
    }        
};

int main() 
{
    auto 
        chain = ChainFunction(AddFunction(), AddFunction(), AddFunction(), PrintFunction());
    chain.ExecuteFunctionLotsAndLotsOfTimes(4);      
}

诚然，以这种方式将成千上万的函数对象链接在一起可能不切实际，但它确实允许您内联（和解耦）几乎所有内容。

编辑

对于这种特定类型的实现还有一个额外的警告：链接函数按值存储。如果你想避免这种情况，只需将 ChainFunctionLink 的成员 first 和 second 重新定义为引用即可。当然，不允许您将临时变量作为参数传递给 ChainFunction...

在此上下文中如何使用 CRTP 删除虚拟方法？

How can I use CRTP to remove virtual method in this context?

c++

templates

crtp