运算符=重载

Question

So we are assigned a project in the class that I am taking right now, and I am stuck trying to figure out how to properly deep copy an array of Cards. Below I will post the entire .cpp and .h for the class I am working on, I am fairly certain that it's in the operator= function, but all I am really looking for is just some tips on how to fix it. vector is not allowed to be use, nor are strings. This is a beginner class and so we do not know too much. The main error I'm receiving is a _BLOCK_TYPE_IS_VALID(pHead->nBlockUse) Please and thanks in advance.

//.h
#pragma once
#include "stdafx.h"
#include "Card.h"



class Player
{

private:

// Needed for unit tests
// DO NOT REMOVE OR RENAME
char* m_name;           // Can change size of array if needed

Card* m_hand;       // Can change size of array if needed


int m_numCards;     // The number of cards the player is currently holding
int m_maxCards;     // The number of cards the player can store (the number of elements in Hand)
int m_score;

public:

Player(const char* _name = "Player", int _maxCards = 5);

Player(const Player& _cpy);

virtual ~Player();

Player& operator=(const Player& _assign);

const char* GetName() const { return m_name; }

bool GetCard(int, Card&) const;

int GetNumCards() const { return m_numCards; }

int GetMaxCards() const { return m_maxCards; }

int GetScore() const { return m_score; }

/*MUTATORS*/

void SetName(const char* _name);

void AddToScore(int addScore);

bool AddCard(Card);

bool Discard(int index, Card&);

void Clear();

virtual void Show() const;




// Needed for unit tests
// DO NOT REMOVE
friend class CTestManager;

};


//.cpp
#include "Player.h"

Player::Player(const char* _name, int _maxCards){
m_name = NULL;
SetName(_name);
m_hand = NULL;

m_hand = new Card[_maxCards];


m_maxCards = _maxCards;
m_numCards = 0;
m_score = 0;
}

Player::Player(const Player& _cpy)
{
    m_name = NULL;
    SetName(_cpy.m_name);
    m_hand = NULL;
    m_hand = new Card(*_cpy.m_hand);


m_maxCards = _cpy.m_maxCards;
m_numCards = _cpy.m_numCards;
m_score = _cpy.m_score;
}

Player::~Player(){
delete[] m_name;
delete[] m_hand;
}

Player& Player::operator=(const Player& _assign)
{
if (this != &_assign)
{

    delete[] m_name;
    SetName(_assign.m_name);

    delete[] m_hand;
            //enter implemented deep copy here//

    m_maxCards = _assign.m_maxCards;
    m_numCards = _assign.m_numCards;

    m_score = _assign.m_score;
}
return *this;
}

bool Player::GetCard(int index, Card& _Card) const{
if (index < m_numCards && index >= 0){
    _Card = m_hand[index];
    return true;
}
return false;
}

/*MUTATORS*/

void Player::SetName(const char* _name){
delete[] m_name;
int len = strlen(_name) + 1;
m_name = new char[len];
strcpy_s(m_name, len, _name);
}

void Player::AddToScore(int addScore){
m_score += addScore;

}

bool Player::AddCard(Card _addCard){
if (m_numCards != m_maxCards){
    m_hand[m_numCards++] = _addCard;
    return true;
}
return false;
}

bool Player::Discard(int discardIndex, Card& _discardCard){
if (discardIndex >= m_numCards){
    return false;
}
else{
    _discardCard = m_hand[discardIndex];
    for (int i = discardIndex; i < m_maxCards - 1; i++){
        m_hand[i] = m_hand[i + 1];
    }
    m_numCards--;
    return true;
}
}

void Player::Clear(){
m_numCards = 0;

}

void Player::Show() const{

}

If there is any tips that anyone can give me I would be greatly appreciative :D Thanks again.

Answer 1

Use std::vector and be done with it. It supports assignment. The question (as I'm writing this) does not indicate a prohibition against using std::vector .

Answer 2

sounds more like a codereview kind of question but anyway here are some "tips":

your copy constructor Player(const Player& _cpy) does not copy the array properly, you need to loop through the _cpy.m_hand and copy each element, what you are doing is basically just copying the first card and also making m_hand point to a single heap element and not an array. this will cause an error when you later delete it since you are assuming m_hand being an array in the dtor (delete [] m_hand).

Player& Player::operator=(const Player& _assign) here you need to first allocate an array to hold the copy, then do a for loop and copy each card to the new array.

eg

m_hand = new Card[_assign.m_maxCards]; 
for (int i = 0; i < _assign.m_numCards; ++i)
{
  m_hand[i] = _assign.m_hand[i]; 
}
m_maxCards = _assign.m_maxCards;
...

Important: The way you copy cards depends on how you implement the Card class but you haven't provided a declaration of Card so I just assume it is a POD type. If it contains more complicated structures then you would need some method to clone its contents.

as a side note: when you declare a class, put the public parts first in the class, the implementation details are normally better kept out of view and are often not (should not be) particularly interesting for the user of the class.

if you must use these old C-style strings then it could be a good idea to create a small helper function which simulates strdup()

char* newdup( const char* str )
{
  char* ret = NULL;
  if ( str != NULL )
  {
    ret = new char[strlen( str ) + 1];
    strcpy_s( ret, len, str );
  }
  return ret; 
}

Answer 3

You have to copy each member in the Player class , So implement a method in Card class by overloading = operator which does the deep copy in the card class. Then you can just use = operator in the Player's method just by adding

m_hand = _assign.m_hand;