小贝子编程

在这种情况下，我如何使用CRTP删除虚拟方法



我具有以下程序类似于我的代码库。一个执行某种算法（可能在多个线程中）的funnatrate类，以及一个控制官能体类别的函数类，并可能执行某些算法设置/拆卸操作。

#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（），这是功能状态类上的虚拟函数。在那里，我执行了很多操作，这些操作可能会从L1缓存中刷出可刷新的指针，从而导致L1缓存错过环路的每次迭代。

因此，我想删除对虚拟呼叫的需求。我决定做这件事的好方法是与CRTP一起使用。FunctionState类将采用实现该类型类型的模板参数并调用其适当的方法，而无需虚拟调用runstate（）。

现在，当我尝试将其移至CRTP时，我遇到了功能类别的一些问题：

  1. 如何转发声明funntrate类（如今已模板）？

  2. 我还需要在功能类中添加模板参数吗？

    3。如果我模板，函数对象的构造会是什么样？如何删除使用函数对象指定类型参数的类的需求？

请注意，这只是我的真实代码库的琐碎版本。真正的代码库是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;
}

基于类型搜索和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;
}

我删除了几个不再需要的课程。
希望代码能够说明自己，如果我可以添加更多详细信息，请在评论中告诉我。

Function必须将非模板类型作为NewFunctionState的返回值，因此您需要附加的base类

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!
    }
};

如果我正确理解您的问题，则可以使用模板链条解决。这是它如何工作的一个粗略示例：

#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);      
}

被授予，例如以这种方式将成千上万的功能对象链在一起可能不切实际，但是它确实使您可以嵌入（和切换）几乎所有内容。

编辑

该特定类型的实现还有一个另外的警告：链接功能是通过Value 存储。如果要避免这种情况，只需重新定义ChainFunctionLink的成员first和second作为参考。不过，您不允许您将临时工作为参数传递给ChainFunction，当然...

相关内容

最新更新


热门标签：

javascript python java c# php android html jquery c++ css ios sql mysql arrays asp.net json python-3.x ruby-on-rails .net sql-server django objective-c excel regex ruby linux ajax iphone xml vba spring asp.net-mvc database wordpress string postgresql wpf windows xcode bash git oracle list vb.net multithreading eclipse algorithm macos powershell visual-studio image forms numpy scala function api selenium