我试图将这些卡在矢量中洗牌

I am trying to shuffle these cards in a vector

本文关键字：更新时间：2023-10-16

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

这是我的两个运算符函数。他们正确实现了吗？

    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();
}

分配运算符未正确实现。在这种情况下，如果您摆脱了定义，则代码可以正常工作，但是我将解释一下以后的参考。

。

分配运算符的返回值通常是对刚分配给对象的副本的引用(因此，如果您编写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的类型卡的局部变量。然后，它将每个数据成员从输入卡复制到本地变量mycard。然后，它通过参考返回本地变量。因此，如果我们有

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

在最后一行中，在括号中，用参数B调用A的分配运算符。在此内，创建了局部变量并给定值(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)
{}

因此，您可以按名称区分参数和数据成员。行为将相同，但这更清晰，更短。

没有找到相关文章