C++ C++；头文件模板

我正在头文件中使用模板。我使用的函数是递归的，我想在函数之外保留两个变量来进行比较。以下是我的代码（注意：未编译）：

#包括“Position.h”
#ifndef\u解算器\u H
#定义解算器
类求解器{
公众：
模板
内部评估职位（T&p、bool me）{
智力得分=0；
if（p.isGameOver（））{
返回p.score（me）；
}
否则{
std:：vector nextMoves=p.getNextPositions（）；
for（int i=0；i！=nextMoves.size（）；i++）{
分数+=评估位置（下一步移动[i]，！me）；
如果（分数>最大分数）{
p、 显示（）；
maxScore=分数；
maxP=p；
p、 显示（）；
}
}
返回分数；
}
}
T maxP；//希望它与函数中使用的类型T相同
整数最大分数；
};
#恩迪夫

---

我试图创建一个与函数中使用的

T

类型相同的泛型变量，以便保存一些数据。这是可能的吗？如果是，将如何实现？

您可以使整个类成为模板化类，而不仅仅是函数

template< class T > class Solver{
    //here goes your function that takes the argument of T class
    int EvaluatePosition(T &p, bool me){
        //...
    }

    T maxP; //here goes your variable
    int maxScore;
};

模板类求解器{
//下面是接受T类参数的函数
内部评估职位（T&p、bool me）{
//...
}
T maxP；//这是您的变量
整数最大分数；
};

当然，您可以为整个类设置模板。假设您不喜欢该调用接口，可以使用本地模板类来保存状态：

class Solver{
  public:
    template<typename T> int EvaluatePosition(T &p, bool me)
    {
        struct Helper {
            T maxP;
            int maxScore;

            int DoEval(T &p, bool me)
            {
                int score = 0;
                if(p.isGameOver()){
                    return p.score(me);
                }
                else{
                    std::vector<T> nextMoves = p.getNextPositions();
                    for(int i=0; i != nextMoves.size(); i++){
                        score += DoEval(nextMoves[i],!me);
                        if(score > maxScore){
                            p.display();
                            maxScore = score;
                            maxP = p;
                            p.display();
                        }
                    }
                    return score;
                }
            }
        } helper;

        return helper.DoEval(p, me);
    }
};

类求解器{
公众：
模板内部评估位置（T&p、bool me）
{
结构辅助程序{
T最大值；
整数最大分数；
int DoEval（T&p、bool me）
{
智力得分=0；
if（p.isGameOver（））{
返回p.score（me）；
}
否则{
std:：vector nextMoves=p.getNextPositions（）；
for（int i=0；i！=nextMoves.size（）；i++）{
分数+=DoEval（下一个移动[i]，！me）；
如果（分数>最大分数）{
p、 显示（）；
maxScore=分数；
maxP=p；
p、 显示（）；
}
}
返回分数；
}
}
}助手；
返回helper.DoEval（p，me）；
}
};

这会影响通话地点（不再进行类型扣减）。此外，这也不是必需的（请参阅我的答案，了解隐藏实现细节的替代方案）

class Solver{
  public:
    template<typename T> int EvaluatePosition(T &p, bool me)
    {
        struct Helper {
            T maxP;
            int maxScore;

            int DoEval(T &p, bool me)
            {
                int score = 0;
                if(p.isGameOver()){
                    return p.score(me);
                }
                else{
                    std::vector<T> nextMoves = p.getNextPositions();
                    for(int i=0; i != nextMoves.size(); i++){
                        score += DoEval(nextMoves[i],!me);
                        if(score > maxScore){
                            p.display();
                            maxScore = score;
                            maxP = p;
                            p.display();
                        }
                    }
                    return score;
                }
            }
        } helper;

        return helper.DoEval(p, me);
    }
};