我試圖洗牌這些卡在一個載體中

Question

 int main() { 

     std::vector<Card> listOfCards; 



     for (int j = 0; j < 52; j++) { 
      Card card(j/13, j % 13); 
      listOfCards.push_back(card); 
     } 


     std::random_shuffle(listOfCards.begin(),listOfCards.end()); 

     for(int i = 0; i < listOfCards.size(); i++) 
      std::cout << listOfCards[i].display() << std::endl; 

我得到的結果與它們在載體中一樣。我嘗試用整數隨機洗牌工作正常。當我洗牌非原始對象時，我需要什麼特別的東西嗎？

This is my Card class 

     class Card{ 
      private: 
      int suit,rank,value; 
      public: 
     Card(); 
     Card(int suit,int rank, int value); 
     Card(int suit,int rank); 

顯示方法

std::string Card::display(){ 
    std::string suits[] = {"Club","Spade","Heart","Diamond"}; 
    std::string ranks[] = 
        {"Ace","2","3","4","5","6","7","8","9","10","Jack","Queen","King"}; 
        return suits[this->suit] + "\t" + ranks[this->rank];} 

類

  Card::Card(int suit, int rank) { 
       this->suit = suit; 
       this->rank = rank; 
       this->value = 0; 

     } 

的構造這是我的兩個運算符重載functions.Are他們正確實施？

Card &Card::operator=(const Card &card) { 
     Card myCard; 
     myCard.suit = card.suit; 
     myCard.value = card.value; 
     myCard.rank = card.rank; 
     return myCard; 
    } 

bool Card::operator<(const Card card) { 
    return this->getRank() < card.getRank(); 
} 

Answer 1

賦值運算符未正確實現。在這種情況下，如果您擺脫了定義，代碼將正常工作，但我會解釋它的錯誤以備將來參考。

賦值運算符的返回值通常是對剛分配的對象副本的引用（因此，如果您寫入x =（A = B），x將是對新對象的引用，在賦值之後具有A的值，並且A，B和x將是三個不同的對象，它們都具有相同的值）。返回值通常不被使用。

如果您編寫自己的拷貝賦值操作符，只要它具有正確的類型，就可以使其返回任何想要的對象。但是，等號左側的對象不會取得返回對象的值。

因此，要解釋你的拷貝賦值運算符是幹什麼的，讓我們看看會發生什麼：

Card &Card::operator=(const Card &card) { 
    Card myCard; 
    myCard.suit = card.suit; 
    myCard.value = card.value; 
    myCard.rank = card.rank; 
    return myCard; 
} 

它發生在被稱爲卡一卡的參考對象。它創建一個稱爲myCard的Card類型的局部變量。然後它將每個數據成員從輸入卡複製到本地變量myCard。然後它通過引用返回本地變量。因此，如果我們有

Card A(1,1); 
Card B(2,2); 
Card x(3,3); 
x = (A=B); 

在最後一行中，括號中的的賦值操作符被調用的這種說法B.內部，局部變量被創建並給出的值（2,2）。這將返回並傳遞給x的賦值運算符。在那裏創建一個局部變量並賦值（2,2），然後在不使用時將其銷燬。最後，沒有任何變化。

你需要做的是這樣的：

Card &Card::operator=(const Card &card) { 
    suit = card.suit; 
    value = card.value; 
    rank = card.rank; 
    return *this; 
} 

這裏，在函數內部，變量訴訟是指對象，其賦值運算符稱爲「西裝」成員，這是在對象上等號的左側。所以，如果你寫

A=B 

那麼，A的賦值操作符被調用，並且A.suit值被修改。

而且，讓我們看看你的構造：

Card::Card(int suit, int rank) { 
      this->suit = suit; 
      this->rank = rank; 
      this->value = 0; 

    } 

更標準的方式來寫，這將是這樣的：

Card::Card(int _suit, int _rank) { 
      suit = _suit; 
      rank = _rank; 
      value = 0; 

    } 

或：

Card::Card(int _suit, int _rank) : suit(_suit), rank(_rank), value(0) 
{} 

所以你可以按名稱區分參數和數據成員。行爲將是相同的，但這是更清楚和更短。