運算符=重載

Question

因此，我們在我現在正在上的課程中分配了一個項目，而我一直試圖找出如何正確深層復制Card系列的方法。 在下面，我將為正在處理的類發布整個.cpp和.h，我可以肯定它位於operator =函數中，但是我真正想要的只是關於如何修復它的一些技巧。 向量不允許使用，字符串也不允許使用。 這是一門初學者，所以我們知道的並不太多。 我收到的主要錯誤是_BLOCK_TYPE_IS_VALID（pHead-> nBlockUse），請提前感謝。

//.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{

}

如果有任何人可以給我的提示，我將非常感激：D再次感謝。

Answer 1

使用std::vector並完成它。 它支持分配。 這個問題（在我寫這篇文章時）並不表示禁止使用std::vector 。

Answer 2

聽起來更像是codereview之類的問題，但無論如何，這里有一些“技巧”：

您的復制構造函數Player(const Player& _cpy)不能正確復制數組，您需要遍歷_cpy.m_hand並復制每個元素，您要做的基本上是復制第一張卡並將m_hand指向單個堆元素而不是數組。 由於您假設m_hand是dtor中的數組（刪除[] m_hand），因此在以后刪除它時將導致錯誤。

Player& Player::operator=(const Player& _assign)在這里，您需要首先分配一個數組來保存副本，然后進行for循環並將每張卡復制到新數組中。

例如

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;
...

重要說明：復制卡的方式取決於實現Card類的方式，但是您沒有提供Card聲明，因此我僅假設它是POD類型。 如果它包含更復雜的結構，則需要某種方法來克隆其內容。

附帶說明：當您聲明一個類時，將公共部分放在該類的第一位，通常最好不要隱瞞實現細節，並且對於類的用戶來說通常（不是應該）特別有趣。

如果您必須使用這些舊的C風格的字符串，那么最好創建一個模擬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

您必須復制Player類中的每個成員，因此，通過重載=運算符在Card類中實現一個方法，該方法會在card類中進行深度復制。 然后，您只需在Player的方法中使用=運算符，只需添加

m_hand = _assign.m_hand;