c++ type erasure

[cnmthmd]

Hello I have problem in my school work
I try to pass in the "Board board" and the Color color to the the Move PlayeMove(const Board& board, Colour c) function, I declare inside struct Model:Concept and I not sure am I declare it correctly?


The following question is

1. Did I declare the 2 variable in correct position

2. How do I pass the 2 variable into player move function? should I pass it in
Model(U&& t)?


I appreciate give me some hint and maybe some tutorial I can follow, prefer with function that need to pass in parameter to call. I been searching online, most of the tutorial is calling const function that did not have any parameter.

https://www.youtube.com/watch?v=ZPk8HuyrKXU
I also found that it will be better if using unique pointer for concept ptr, so far I did not learned this yet.

class Player
{
  public:
  // forwarding constructor
  template<typename T,
         typename U = typename std::enable_if
         <!std::is_same<typename std::decay<T>::type,Player>::value>::type >
  Player(T&& t)
  : ptr(new Model<T>(std::forward<T>(t)))
  {  
    
  }
  // copy constructor using clone 
  Player(const Player& rhs)
  : ptr(rhs.ptr->clone())  
  {
      
  }
  // copy assignment
  Player& operator=(const Player& rhs)
  {
      Concept *tmp(rhs.ptr->clone());
      delete ptr;
      ptr=tmp;
      return *this;
  }
  // destructor
  ~Player()
  {
     delete ptr;
  }
  
  //  the function that the human player and computer player have
  Move PlayeMove(const Board& board, Colour c)
  {
      
  }
    
  private:
    // the concept struct
    struct Concept
    {
      virtual Concept* clone() = 0;
      virtual Move PlayeMove(const Board& board, Colour c) =0;
      ~Concept()
      {
        
      }
    }
    
    // the model struct inherit form the concept
    template<typename T>  
    struct Model : Concept
    {
      template<typename U>
      Model(U&& t)
      :obj(std::forward<U>(t))
      {
        
      }
      
      Model<T>* clone() 
      { 
        return new Model(obj);
      }
      
      Move PlayeMove(const Board& board, Colour c)override;
      { 
        obj.PlayeMove(board, c); 
      }
      T obj;

     // the variable i want pass it in to move
      Board board;
      Colour colour;
      /****************************************/
    }
    Concept *ptr;
};

class HumanPlayer
{
public:
Move PlayMove ( const Board& board, Colour c )
{

}
};

class ComputerPlayer
{
public:
Move PlayMove ( const Board& board, Colour c )
{

}
};

[mbozzi]

Why must ComputerPlayer and HumanPlayer be unrelated classes?

[cnmthmd]

Because, human player can choose the move and computer player will need implement ai logic

[mbozzi]

Typically, the solution would be to introduce straightforward run-time polymorphism: both player classes would inherit from a single Player class, and implement a virtual function named Move.

Type erasure is a mechanism to unify static and run-time polymorphism. It allows you to homogenize types that each supply a similar interface, when those types are entirely unrelated - i.e., when they don't (or can't be made to) share a base class supplying that interface. It isn't a technique that you would ordinarily apply.

You'd pass the arguments to Player::PlayeMove when you call it.