您将如何在模板中定义未定义的函数？

Question

我正在编写一个 C++ 项目，并且在类模板中有一个通用的评估方法。

我唯一的问题是如何定义 generateAllMoves 和 isPosFinal 以便在使用该类模板的类中定义它？

我读到使用纯虚函数是不行的。我也不想让它静态。

我预见自己会将其重写为抽象类，但最终会遇到需要泛型类型的问题。

#ifndef ENGINE_H
#define ENGINE_H

#include <map>

using namespace std;

template< class M, class P >

class Engine {

public:

  Engine() { };  

  struct Move {
    P move;
    P pos;
    int score;
  };

  Move evaluate( P position ) {

    Move best;      

    if ( posIsFinal( position ) ) {
      Move newMove;
      newMove.pos = position;
      newMove.score = 1;
      return newMove;
    }

    else {

      map< M , P > allMoves = generateAllMoves( position );

      typename map< M , P > :: iterator it;

      for (it = allMoves.begin(); it != allMoves.end(); it++ ) {
        Move next = evaluate(it->second);

        if (next.score > best.score ) {
          best.pos = next.pos;
          best.move = next.move;
          best.score = next.score;
        }
      }
      return best;
    }
  }
};

#endif

编辑：为了让大家更清楚！

我有两个不同的游戏，它们定义了自己的generateAllMoves 和isPosFinal 方法。它们使用不同的算法并返回不同的类型......例如，我很快就会实现一个国际象棋游戏，但现在我正在实现 nim。两者对移动和该位置最终的解释不同。

第二次编辑：

最终代码编译！

#ifndef ENGINE_H
#define ENGINE_H

#include <map>

using namespace std;

template< typename Derived, class M, class P >

class Engine {

public:

  struct Move {
    P move;
    P pos;
    int score;
  };

  Move evaluate( P position ) {

    Move best;      

    if ( static_cast<Derived*>(this)->posIsFinal( position ) ) {
      Move newMove;
      newMove.pos = position;
      newMove.score = 1;
      return newMove;
    }

    else {

      map< M , P > allMoves = static_cast<Derived*>(this)->generateAllMoves( position );

      typename map< M , P > :: iterator it;

      for (it = allMoves.begin(); it != allMoves.end(); it++ ) {
        Move next = evaluate(it->second);

        if (next.score > best.score ) {
          best.pos = next.pos;
          best.move = next.move;
          best.score = next.score;
        }
      }
      return best;
    }
  }

  bool posIsFinal( P position ) {
    cerr << "Generic posIsFinal\n";
    exit(1);
  }

  map< M , P > generateAllMoves( P position ) {
    cerr << "Generic generateAllMoves\n";
    exit(1);
  }

private:


};

#endif

Answer 1

做到这一点的一个好方法是使用“奇怪的递归模板参数”习惯用法。

请参阅此处了解更多信息。

Answer 2

您可以为引擎创建一个具有所有必要参数化的特征类：

template< class EngineTraits >
class Engine {

  typedef typename EngineTraits::P_type P;
  typedef typename EngineTraits::M_type M;

public:

  Engine() { };  

  struct Move {
    P move;
    P pos;
    int score;
  };

  Move evaluate( P position ) {

    Move best;      

    if ( EngineTraits::posIsFinal( position ) ) {
      Move newMove;
      newMove.pos = position;
      newMove.score = 1;
      return newMove;
    }

    else {
      typedef typename EngineTraits::moves_mapping_type MovesMapping;
      MovesMapping allMoves = EngineTraits::generateAllMoves( position );

      typename MovesMapping::iterator it;

      for (it = allMoves.begin(); it != allMoves.end(); it++ ) {
        Move next = evaluate(it->second);

        if (next.score > best.score ) {
          best.pos = next.pos;
          best.move = next.move;
          best.score = next.score;
        }
      }
      return best;
    }
  }
};

现在您可以通过定义适当的特征类来自定义您的引擎：

struct my_engine_traits
{
  typedef some-type P_type;
  typedef some-type M_type;
  typedef std::map<M_type, P_type> moves_mapping_type;

  static bool posIsFinal(P_type const &position)
  {
    // ...
  }

  static moves_mapping_type generateAllMoves(P_type const &position)
  {
    // ...
  }
};

或者您也可以使您的引擎客户端类成为引擎特征：

class my_engine_client
{
  typedef some-type P_type;
  typedef some-type M_type;
  typedef std::map<M_type, P_type> moves_mapping_type;

  static bool posIsFinal(P_type const &position)
  {
    // ...
  }

  static moves_mapping_type generateAllMoves(P_type const &position)
  {
    // ...
  }

  typedef Engine<my_engine_client> Engine;
  Engine m_engine;  
};

当然您可以改变直接传递的内容作为引擎模板参数以及要移动到单个 traits 类的内容，例如：

template< class M, class P, class PositionProcessor >
class Engine {
// ...
};

Answer 3

不是特别是朋友的朋友函数，但是像这样的函数怎么样：

template< class M, class P >
class Engine {
public:
  friend void generateAllMoves(P position);
  void evaluate( P position )
  {
    ...
    generateAllMoves(position);
    ...
  }
};

// here your specific function

void generateAllMoves(int position )
{ 
  ;
}

int main(int argc, char* argv[])
{
// then instantiate it
  Engine<int,int> X;

  ..