copying a class in c++

class c_piece{public:    c_piece();    c_piece(piece_type piece, int p_player);    void Remove();    bool       alive;    piece_type type;    int        player;};class c_player{public:    c_player();    void Reset();    //void AddPiece(c_piece piece);    void AddPiece(const c_piece& piece);        // For the most part, the only time you want to pass an argument by pointer is    // when it is not a precondition of the function that the pointer be valid (for    // example, if the argument represents an optional output parameter). That's not the    // case here, so we'll make it a reference (which means it will always be valid under    // normal circumstances), and will also make it constant (which means the object    // cannot be modified within the function). Making the argument a constant reference    // is both safer and more expressive of our intent. (I also made the argument to    // AddPiece() pass-by-reference rather than pass-by-value - this is discussed later.)    //void copy(c_player *player);    void copy(const c_player& player);    std::vector< c_piece > pieces;};class c_map{public:    c_map();    board_state MovePieces(int start, int end);    bool IsMovementLegal(int start, int end);    board_state SetMovement(int start, int end);    game_state GetGameState();    c_piece GetPiece(int position);    void Initiate();    //void copy(c_map *map);    void copy(const c_map& map);    public:    bool    player1_turn;    c_piece no_piece;        // Although the type of array used was not related to your problem, it's certainly a    // good idea to use stuff from Boost where appropriate. Just as a point of interest,    // boost::array is really just a very thin wrapper around a regular C-style array.    // It's main purpose is to provide an interface that a) is similar to std::vector    // (specifically the functions operator[]() and at()), and b) is consistent with other    // standard library containers (begin(), end(), and so on). Regular 'raw' arrays are    // already compatible with most algorithms from the standard library, but with    // boost::array you get greater consistency (and a bit more flexibility, in the sense    // that you can 'typedef' a boost array and then interchange it freely with other    // containers).        //c_piece *pieces[6][6];        enum { BOARD_DIM_X = 6, BOARD_DIM_Y = 6 };    //boost::array<boost::array<c_piece*,6>,6> pieces;    boost::array< boost::array< c_piece*, BOARD_DIM_X >, BOARD_DIM_Y > pieces;    private:    // This is personal preference, but I try to order things in a class header according    // to how 'visible' or 'important to the outside world' they are. A class's public    // interface is obviously of greatest interest to the 'outside world' - in fact, it's    // all that the outside world (aside from friends of the class) knows about the class.        // The same argument applies to protected and private members, although here we're not    // concerned about the outside world, but rather the class itself and any classes that    // inherit from it.        // So I've shuffled things around in your header a bit to reflect this.     board_state MovementState(int start, int end);    board_state DoMovement(int start, int end);    // A standard bit of wisdom: use named constants or enums rather than 'magic numbers'    // where possible. Someone recently put it very well in the For Beginners forum by    // saying, "In general, use a named constant for any value other than 0 or 1". We'll    // go ahead and apply that here (and also earlier with the 'pieces' member variable):        enum { NUM_PLAYERS = 2 };    //c_player player[2];    boost::array< c_player, NUM_PLAYERS > player;    game_state                            how_is_it_going;};// Google 'c++ initializer list' for an explanation of the following syntax:c_piece::c_piece(piece_type piece, int p_player) :    alive(true),    type(piece),    player(p_player){    //alive = true;    //type = piece;    //player = p_player;}// For non-trivial types, you usually want to pass by constant reference rather than by// value, as it's often less costly (since the object doesn't need to be copied).//void c_player::AddPiece(c_piece piece)void c_player::AddPiece(const c_piece& piece){    // push_back() makes a copy of the argument, so there's no need to create a new piece    // here - we can just push back the one passed in:    //c_piece new_piece(piece.type, piece.player);    //pieces.push_back(new_piece);    pieces.push_back(piece);}//void c_map::copy(c_map *map)void c_map::copy(const c_map& map){    // We don't need these, as we'll see in a minute.    //int total_pieces1 = 0;    //int total_pieces2 = 0;        // Personal preference, but I usually use an unsigned type when the intention is that    // values will only ever be non-negative. I think it's clearer.        // Also, it probably doesn't matter in this case whether you use pre- or post-    // increment, but with some types, post-increment may require that a copy of the    // object be made. Therefore it's good to get in the habit of favoring pre-increment    // when the end effect is the same (as is the case here).    //for (int i = 0; i < 6; i++)    for (size_t i = 0; i < BOARD_DIM_X; ++i)    {        //for (int j = 0; j < 6; j++)        for (size_t j = 0; j < BOARD_DIM_Y; ++j)        {            // It doesn't look like the value of 'player' is modified in these blocks of            // code, so these can be if else's (or switch cases):            if(map->pieces[j]->player == 0)            {                // The parentheses aren't necessary here and don't contribute anything in                // terms of clarity, IMO.                //pieces[j] = &(no_piece);                pieces[j] = &no_piece;            }            //if(map->pieces[j]->player == 1)            else if(map->pieces[j]->player == 1)            {                // The next block can be cleaned up in a couple of ways. First of all, we                // can construct a temporary object for the argument to AddPiece(), saving                // a couple of lines. Secondly, the vector function back() obviates the                // need for the total_pieces1 variable.                // Also, 'magic numbers' are showing up again. I had to go look at the                // declaration for the piece class to see what the '1' meant, whereas if                // it were a named constant - say, PLAYER_ONE - it would have been                // immediately clear. So this is a case where even the literal '1' would                // be better off as a named constant :)                                //piece_type type = map->pieces[j]->type;                //c_piece new_piece(type, 1);                //player[0].AddPiece(new_piece);                //pieces[j] = &player[0].pieces[total_pieces1];                //total_pieces1++;                                player[0].AddPiece(c_piece(map->pieces[j]->type, 1));                pieces[j] = &player[0].pieces.back();                                // We've of course already addressed the logic error here concerning                // vector memory re-allocation.            }            //if(map->pieces[j]->player == 2)            else if(map->pieces[j]->player == 2)            {                //piece_type type = map->pieces[j]->type;                //c_piece new_piece(type, 2);                //player[1].AddPiece(new_piece);                //pieces[j] = &player[1].pieces[total_pieces2];                //total_pieces2++;                player[1].AddPiece(c_piece(map->pieces[j]->type, 2));                pieces[j] = &player[1].pieces.back();                      }        }    }        // Use of the 'this' pointer isn't necessary here:    //this->player1_turn = map->player1_turn;    //this->how_is_it_going = map->how_is_it_going;    player1_turn = map->player1_turn;    how_is_it_going = map->how_is_it_going;}// Issues left unaddressed include some aspects of constant correctness, public vs.// private member data, and naming conventions for classes and member variables.

void c_map::copy(const c_map& map){    int piece_index1 = 0;    int piece_index2 = 0;    for (size_t i = 0; i < BOARD_X_SIZE; ++i)    {    	for (size_t j = 0; j < BOARD_Y_SIZE; ++j)    	{			if(map.pieces[j]->player == PLAYER_ONE)			{	//(player[0] is actually player one)				player[0].AddPiece(c_piece(map.pieces[j]->type, PLAYER_ONE));					}			else if(map.pieces[j]->player == PLAYER_TWO)			{	//(player[1] is actually player two)				player[1].AddPiece(c_piece(map.pieces[j]->type, PLAYER_TWO));				}    	}    }		for (size_t i = 0; i < BOARD_X_SIZE; ++i)    {    	for (size_t j = 0; j < BOARD_Y_SIZE; ++j)    	{			pieces[j] = &(no_piece);			if(map.pieces[j]->player == PLAYER_ONE)			{				//piece-index is a hack, but it works, because the pieces will be read				//at the same order that they were placed on player.pieces.				pieces[j] = &player[0].pieces[piece_index1];				piece_index1++;			}			else if(map.pieces[j]->player == PLAYER_TWO)			{				pieces[j] = &player[1].pieces[piece_index2];				piece_index2++;			}    	}    }    player1_turn = map.player1_turn;    how_is_it_going = map.how_is_it_going;}