C++ 生成一副牌

我想做一个简单的21点程序。可悲的是，我在生成一副牌时遇到了问题

#include <iostream>
#include <vector>

using namespace std;

int main() {
    vector<char> deck;
    char suit[] = {'h','d','c','s'};
    char card[] = {'2','3','4','5','6','7','8','9','10','J','Q','K','A'};
    for (int j=0; j<13; j++) {
        for (int i=0; i<4; i++) {
            deck.push_back(card[j] suit[i]);
        }       
    }

    return 0;
}

#包括
#包括
使用名称空间std；
int main（）{
向量甲板；
char suit[]={'h'，'d'，'c'，'s'}；
字符卡[]={'2'，'3'，'4'，'5'，'6'，'7'，'8'，'9'，'10'，'J'，'Q'，'K'，'A'；
对于（int j=0；j用“T”代替10。
你试过用11代替j，用12代替Q，用13代替K吗？然后你可以用
int
egers而不是
char
acters。稍后用合适的字母代替11-13。
试着用suit和Card作为成员创建一个卡片类，并将其设置为向量类型。如

public class Card {
 public:
  Card(char suit, char card);
  char suit, card;
};

int main() {
    vector<Card> deck;
    char suit[] = {'h','d','c','s'};
    char card[] = {'2','3','4','5','6','7','8','9','T','J','Q','K','A'};
    for (int j=0; j<13; j++) {
        for (int i=0; i<4; i++) {
                deck.push_back(new Card(card[j],suit[i]));
        }               
    }
    return 0;
}

公共类卡{
公众：
卡片（字符套装、字符卡）；
卡片；
};
int main（）{
向量甲板；
char suit[]={'h'，'d'，'c'，'s'}；
字符卡[]={'2'，'3'，'4'，'5'，'6'，'7'，'8'，'9'，'T'，'J'，'Q'，'K'，'A'；
对于其他人提到的（int j=0；j，可以使用'T'表示十，j，Q和K表示数字。
至于push_back..由于deck是一个字符向量，您只能将一个字符作为参数传递给push_back。同时传递卡片值（1…9，T，J，Q，K）及其套件不起作用

我个人会创建一个小结构，用一个值和一个Suite属性来表示一张卡。然后，你可以把你的牌组变成一个卡向量

编辑：修复向量（小于）卡（大于）被渲染为向量（无）后的最后一个单词。
首先，卡组[0]是一个字符，但您正在尝试将“2h”填充到其中。（目前，我们将忽略您这样做是错误的。）

基本上，您需要将卡片组制作成一个
向量
。将卡片制作成一个const char*s数组，并将元素转换成字符串

然后使用：

deck.push_back(std::string(card[j]) + suit[i]);

我认为您希望使用的是枚举。它将使您的代码更清晰，并解决您的问题

enum SUIT { HEART, CLUB, DIAMOND, SPADE }; 
enum VALUE { ONE, TWO, THREE, ..., TEN, JACK, QUEEN, KING};

由于这是一个21点程序，您将添加和比较卡的价值

在这种情况下，您可以通过给卡片提供int值（1-13）而不是char值来节省一些额外的编程和痛苦。
我同意罗斯的建议，使用整数。大多数纸牌游戏都会涉及一些数学知识，因此这是一种更好的表示

在输出时转换为“A”或“ACE”等。
建模的方式实际上取决于您试图做什么

您是否正在创建一个实际的游戏，并且数据结构只需要支持游戏性

如果是这样，我会创建一个card类，其中一个enum字段用于套装，一个数字类型（值为1-13）用于面值

另一方面，如果您正在构建一个分析应用程序或AI播放器，那么模型可能会有点不同

几年前，我编写了一个模拟器来计算各种德克萨斯Holdem场景中的概率，我希望它能够非常快速地处理数字。我从一个非常简单的模型（card类、suit enum等）开始，但在进行了大量分析和优化之后，我最终得到了位表示

每张卡片都是一个16位的值，其中13个高阶位代表面值，两个低阶位代表套装，位[2]作为一个特殊的标志表示ace（仅在ace可能出现在A2345直线中的情况下使用）

以下是几个例子：

0000000000001001  <----  Two of hearts
0100000000000011  <----  King of spades
1000000000000110  <----  Ace of diamonds

^^^^^^^^^^^^^            ("face-value" bits)
             ^           ("low-ace" flag)
              ^^         ("suit" bits)

<代码> 000000000000 1001 > P>因为这是C++的作业，我想你应该使用类。
否则使用枚举，如果是C，则使用结构或其他

对于某些游戏，除了积分值之外，你还需要为卡片存储某种等级，这取决于当前的游戏模式

我从来没有做过简单的C，但我的意思是：

typedef struct struct_card {
  unsigned short int suit:2;
  unsigned short int card:4;
//  unsigned short int valu:4;
} card;

int main() {
  card a_card;
  card std_deck[52];
  const unsigned short int rummy_value[13] = {1,2,3,4,5,6,7,8,9,10,10,10,10};
  const char *std_card_name[13] = {"Ace","Two","Three","Four","Five","Six",
    "Seven","Eight","Nine","Ten","Jack","Queen","King"};
  const char *std_suit_name[4] = {"Spades","Clubs","Hearts","Diamonds"};

  int j, k, i=0;
  for(j=0; j<4; j++){
    for(k=0; k<13; k++){
      a_card.suit=j; a_card.card=k;
      std_deck[i++] = a_card;
    }
  }

  //check our work
  printf("In a game of rummy:\n");
  for(i=0;i<52;i++){
    printf("  %-5s of %-8s is worth %2d points.\n",
        std_card_name[std_deck[i].card],
        std_suit_name[std_deck[i].suit],
        rummy_value[std_deck[i].card]);
  }

  //a different kind of game.
  enum round_mode {SHEILD_TRUMP, FLOWER_TRUMP, BELL_TRUMP, ACORN_TRUMP, BOCK, GEISS} mode;
  const card jass_deck[36]={
    {0,0},{0,1},{0,2},{0,3},{0,4},{0,5},{0,6},{0,7},{0,8},
    {1,1},{1,1},{1,2},{1,3},{1,4},{1,5},{1,6},{1,7},{1,8},
    {2,2},{2,1},{2,2},{2,3},{2,4},{2,5},{2,6},{2,7},{2,8},
    {3,3},{3,1},{3,2},{3,3},{3,4},{3,5},{3,6},{3,7},{3,8},
  };
#define JASS_V {11,0,0,0,0,10,2,3,4}
  const unsigned short int jass_value[9] = JASS_V;
#define JASS_TRUMP_V {11,0,0,0,14,10,20,3,4}
  const unsigned short int jass_trump_value[9] = JASS_TRUMP_V;
#define JASS_BOCK_V {11,0,0,8,0,10,2,3,4}
  const unsigned short int jass_bock_value[9] = JASS_BOCK_V;
#define JASS_GEISS_V {0,11,0,8,0,10,2,3,4}
  const unsigned short int jass_geiss_value[9] = JASS_GEISS_V;
  const char *jass_card_name[9] = {"Ace","Six","Seven","Eight","Nine","Banner",
    "Under","Ober","King"};
  const char *jass_suit_name[4] = {"Sheilds","Flowers","Bells","Acorns"};
  const unsigned short int jass_all_value[6][4][9] = {
    { JASS_TRUMP_V, JASS_V, JASS_V, JASS_V },
    { JASS_V, JASS_TRUMP_V, JASS_V, JASS_V },
    { JASS_V, JASS_V, JASS_TRUMP_V, JASS_V },
    { JASS_V, JASS_V, JASS_V, JASS_TRUMP_V },
    { JASS_BOCK_V, JASS_BOCK_V, JASS_BOCK_V, JASS_BOCK_V },
    { JASS_GEISS_V, JASS_GEISS_V, JASS_GEISS_V, JASS_GEISS_V }
  };

  //check our work 2: work goes on summer vacation
  printf("In a game of jass with trump (Sheilds | Flowers | Bells | Acorns) | Bock | Geiss\n");
  for(i=0;i<36;i++){
    printf("  %-6s of %-7s is worth %8d%10d%8d%9d%8d%8d\n",
        jass_card_name[jass_deck[i].card],
        jass_suit_name[jass_deck[i].suit],
        jass_all_value[SHEILD_TRUMP][jass_deck[i].suit][jass_deck[i].card],
        jass_all_value[FLOWER_TRUMP][jass_deck[i].suit][jass_deck[i].card],
        jass_all_value[BELL_TRUMP][jass_deck[i].suit][jass_deck[i].card],
        jass_all_value[ACORN_TRUMP][jass_deck[i].suit][jass_deck[i].card],
        jass_all_value[BOCK][jass_deck[i].suit][jass_deck[i].card],
        jass_all_value[GEISS][jass_deck[i].suit][jass_deck[i].card]);
  }
  return 0;
}

for(int suit = 1; suit <= 4; suit++){
    for(int card = 1; card <= 13; card++){
        // Add card to array
    }
}

21点很无聊。
这段代码是可以编译的。
这可能无法编译，但这是我会（并且已经使用过）的方法。您可能希望使用int来表示卡，但您可以轻松地在类中抽象它。我将为您编写

class Card
{
public:
    enum ESuit
    {
        kSuit_Heart,
        kSuit_Club,
        kSuit_Diamond,
        kSuit_Spade,
        kSuit_Count
    };

    enum ERank
    {
        kRank_Ace,
        kRank_Two,
        kRank_Three,
        kRank_Four,
        kRank_Five,
        kRank_Six,
        kRank_Seven,
        kRank_Eight,
        kRank_Nine,
        kRank_Ten,
        kRank_Jack,
        kRank_Queen,
        kRank_King,
        kRank_Count
    };

    static int const skNumCards = kSuit_Count * kRank_Count;

    Card( int cardIndex )
    : mSuit( static_cast<ESuit>( cardIndex / kRank_Count ) )
    , mRank( static_cast<ERank>( cardIndex % kRank_Count ) )
    {}

    ESuit GetSuit() const { return mSuit );
    ERank GetRank() const { return mRank );

private:
    ESuit mSuit;
    ERank mRank;
}

类卡
{
公众：
枚举电路
{
克苏蒂欧之心，
克苏伊俱乐部，
克苏伊图钻石酒店，
黑桃，
克苏伊计数
};
艾伦克伯爵酒店
{
克朗克王牌，
克朗克二号，
克朗克三号，
克朗克四号，
克朗克五号，
克朗克六号，
克朗克七号，
克朗克八号，
克朗克九号，
克朗克顿，
克朗克·杰克，
克朗克女王，
克朗克·金，
克朗克计数
};
静态int const skNumCards=kSuit_Count*kRank_Count；
卡片（国际卡迪克斯）
：mSuit（静态铸造（卡迪克斯/克朗克计数））
，mRank（静态铸造（卡迪德百分数）
{}
ESuit GetSuit（）常量{返回mSuit）；
ERank GetRank（）常量{return mRank）；
私人：
ESuit mSuit；
ERank mRank；
}

现在，将其添加到这个类中以获得所需的一切非常简单。
要生成列表，其操作如下所示

rstl::vector<Card> mCards;
mCards.reserve( Card::skNumCards );

for ( int cardValue = 0; cardValue < Card::skNumCards; ++cardValue )
{
    mCards.push_back( Card( cardValue ) );
}

rstl:：向量mCards；
mCards.reserve（卡片：skNumCards）；
对于（int cardValue=0；cardValue

你需要洗牌吗

#include <algorithm>
std::random_shuffle( mCards.begin(), mCards.end() );

#包括
std:：random_shuffle（mCards.begin（），mCards.end（））；

看看第一张卡的价值是多少

if ( mCards[0].GetSuit() == Card::kRank_Club && mCards[0].GetRank() == Card::kRank_Ace )
{
    std::cout << "ACE OF CLUBS!" << std::endl;
}

if（mCards[0].GetSuit（）==Card:：kRank_Club&&mCards[0].GetRank（）==Card:：kRank_Ace）
{
STD:：P>我创建的时候，我遇到了一些自己的问题。首先，我尝试用最小的运气转换成C++。我决定坐下来，把它放在纸上。我决定去用一个面向对象的设置，主要是因为我觉得它是最容易用于扩展的。我使用的对象是“强>卡< /强>和<强>甲板< /强。>例如，如果你想在21点游戏的鞋中放入10副牌，你可以创建10副牌，这很简单，因为我
#include "AnubisCards.cpp"

int main() {

    Deck *shoe = new Deck(10);

}

for(int suit = 1; suit <= 4; suit++){
    for(int card = 1; card <= 13; card++){
        // Add card to array
    }
}