C++ 分段错误（C+；+；）

到目前为止，我的代码旨在创建一副牌，计算每个组别的

9-ACE

，并给4名玩家发5张牌。这些牌是发

3-2-3-2

，然后是

2-3-2-3

，因此每位玩家总共有5张牌。稍后我将编写代码来洗牌，然后在euchre游戏中比较它们，但现在我只想发牌。不管怎么说，这根本不起作用，我愿意接受建议。我得到的错误是“分段错误：11”

#包括
#包括
#包括
#包括
使用名称空间std；
智能卡[24]//充满卡值的数组
字符组[24][25]=
{//由卡片名称填充的数组。用于处理//24个元素长//每个元素中25个字符
“黑桃王牌”、“黑桃九”、“黑桃十”、“黑桃杰克”、“黑桃皇后”、“黑桃之王”，
“红桃王牌”、“红桃九”、“红桃十”、“红桃杰克”、“红桃皇后”、“红桃之王”，
“梅花王牌”、“梅花九”、“梅花十”、“梅花杰克”、“梅花女王”、“梅花之王”，
“钻石王牌”、“钻石九”、“钻石十”、“钻石杰克”、“钻石女王”、“钻石之王”
};
内部主（空）
{
字符P1[5][25]；
字符P2[5][25]；
字符P3[5][25]；
字符P4[5][25]；
for（int i=0；i<24；++i）//用于卡的总数
{
对于（int j=0；j<25；j++）
{
//第一笔交易3-2-3-2
如果（i<3）//0-2//3卡
{
P1[i][j]=甲板[i][j]；
}
如果（（i>2）和&（i<5））//3-4//2卡
{
P2[i][j]=甲板[i][j]；
}
如果（（i>4）和&（i<8））//5-7//3张卡
{
P3[i][j]=甲板[i][j]；
}
如果（（i>7）和&（i<10））//8-9//2张卡
{
P4[i][j]=甲板[i][j]；
}
//第二笔交易2-3-2-3
如果（（i>9）和&（i<12））//10-11//2张卡
{
P1[i][j]=甲板[i][j]；
}
如果（（i>11）和&（i<15））//12-14//3张卡
{
P2[i][j]=甲板[i][j]；
}
如果（（i>14）&（i<17））//15-16//2张卡
{
P3[i][j]=甲板[i][j]；
}
如果（（i>16）和&（i<20））//17-19//3张卡
{
P4[i][j]=甲板[i][j]；
}
}
}
对于（int q=0；q<5；++q）
{
让我“教你钓鱼”：

调试器将准确地告诉您错误所在。如果您使用的是IDE（Xcode、Eclipse、VS），它有一个很好的接口，您应该使用它。如果不是：

$ gdb my_executable
...
> run
...
Segmentation fault
> where

这将为您提供准确的位置（哪个函数在哪个行号上）。
让我“教您钓鱼”：

调试器将准确地告诉您错误所在。如果您使用的是IDE（Xcode、Eclipse、VS），它有一个很好的接口，您应该使用它。如果不是：

$ gdb my_executable
...
> run
...
Segmentation fault
> where

这将为您提供准确的位置（哪个函数在哪个行号上）。
您有这样的数组

char P1[5][25];

但在代码中，您将值分配给
i
索引大于5的元素。您必须限制索引分配给有效且在范围内的元素。仅分配给
P1[i][j]的值才有效
对于介于0和4之间的
i
和介于0和24之间的
j
。如果偏离此值，则可能会出现分段错误的风险，因为不应将其分配给数组边界之外的内存位置。
您有这样的数组

char P1[5][25];

 if((i > 4) && (i < 8)) // 5 - 7 // 3 cards
  {
    P3[i][j] = DECK[i][j];

但在代码中，您将值分配给
i
索引大于5的元素。您必须限制索引分配给有效且在范围内的元素。仅分配给
P1[i][j]的值才有效
对于介于0和4之间的
i
和介于0和24之间的
j
。如果您偏离此设置，您将面临分段错误的风险，因为您不应分配给数组边界之外的内存位置。
如果（（i>4）和（（i<8））//5-7//3卡
 if((i > 4) && (i < 8)) // 5 - 7 // 3 cards
  {
    P3[i][j] = DECK[i][j];

{
P3[i][j]=甲板[i][j]；

您将分配给P3[5]…P3[6]…P3[7]…而这是不存在的。稍后您将对更大的索引执行相同的操作。您必须使用i=[0,4]j=[0,24]
if（（i>4）和&（i<8））//5-7//3卡
{
P3[i][j]=甲板[i][j]；

您将分配给P3[5]…P3[6]…P3[7]…这是不存在的。稍后您将对更大的索引执行相同的操作。您必须使用i=[0,4]j=[0,24]
请允许我从稍微不同的角度“教您钓鱼”

你的代码使用两个常量，24和25。我很难阅读你的代码，因为你似乎为了不同的目的使用了25两次

不要使用原始常量数字，而是给它们起有意义的名字。这将有助于你记录代码，但也有助于你避免愚蠢的错误。有三种方法可以做到这一点

C风格：

#define NUM_CARDS_IN_DECK 24

优点：在此之后，无论您在何处写入'NUM_CARDS_IN_DECK'，编译器都会看到常量“24”，并进行适当的类型转换。缺点：您无法在调试器中分辨该值来自何处

枚举：

优点：出现在一些调试器中，缺点：有时您可能需要强制转换

枚举：

优点：强类型，通常出现在调试器中，缺点：强类型

但让我们看看这是如何改变您的代码的：

static const size_t NumCardsInDeck = 24;
static const size_t MaxCardNameLength = 25;

int cards[NumCardsInDeck];
char DECK[NumCardsInDeck][MaxCardNameLength] =
{
    "Ace of Spades", "Nine of Spades", "Ten of Spades", "Jack of Spades", "Queen of Spades", "King of Spades",
    "Ace of Hearts", "Nine of Hearts", "Ten of Hearts", "Jack of Hearts", "Queen of Hearts", "King of Hearts",
    "Ace of Clubs", "Nine of Clubs", "Ten of Clubs", "Jack of Clubs", "Queen of Clubs", "King of Clubs",
    "Ace of Diamonds", "Nine of Diamonds", "Ten of Diamonds", "Jack of Diamonds", "Queen of Diamonds", "King of Diamonds" 
};

int main()
{
    char P1[5][MaxCardNameLength];
    char P2[5][MaxCardNameLength];
    char P3[5][MaxCardNameLength];
    char P4[5][MaxCardNameLength];

    for(size_t i = 0 ; i < NumCardsInDeck; ++i) // for the total amount of cards
    {
        for(int j = 0; j < 25; j++)

static const size\u t NumCardsInDeck=24；
静态常量大小\u t MaxCardNameLength=25；
int卡[NumCardsInDeck]；
字符组[NumCardsInDeck][MaxCardNameLength]=
{
“黑桃王牌”、“黑桃九”、“黑桃十”、“黑桃杰克”、“黑桃皇后”、“黑桃之王”，
“红桃王牌”、“红桃九”、“红桃十”、“红桃杰克”、“红桃皇后”、“红桃之王”，
“梅花王牌”、“梅花九”、“梅花十”、“梅花杰克”、“梅花女王”、“梅花之王”，
“钻石王牌”、“钻石九”、“钻石十”、“钻石杰克”、“钻石女王”、“钻石之王”
};
int main（）
{
字符P1[5][MaxCardNameLength]；
字符P2[5][MaxCardNameLength]；
字符P3[5][MaxCardNameLength]；
字符P4[5][MaxCardNameLength]；
for（size_t i=0；i

这里
        for(size_t j = 0; j < MaxCardNameLength; j++)

static const size_t NumCardsInDeck = 24;
static const size_t NumCardsPerHand = 5;

int cards[NumCardsInDeck];
const char* DECK[NumCardsInDeck] =
{
    "Ace of Spades", "Nine of Spades", "Ten of Spades", "Jack of Spades", "Queen of Spades", "King of Spades",
    "Ace of Hearts", "Nine of Hearts", "Ten of Hearts", "Jack of Hearts", "Queen of Hearts", "King of Hearts",
    "Ace of Clubs", "Nine of Clubs", "Ten of Clubs", "Jack of Clubs", "Queen of Clubs", "King of Clubs",
    "Ace of Diamonds", "Nine of Diamonds", "Ten of Diamonds", "Jack of Diamonds", "Queen of Diamonds", "King of Diamonds" 
};

int main()
{
    const char* P1[NumCardsPerHand];
    const char* P2[NumCardsPerHand];
    const char* P3[NumCardsPerHand];
    const char* P4[NumCardsPerHand];

    for(size_t i = 0 ; i < NumCardsInDeck; ++i) // for the total amount of cards
    {
        if(i < 3)
        {
            P1[0] = DECK[i];
        }
        else if(i < 6)  // it's an else, so i > 2 is already implied.
        {
            P1[1] = DECK[i];
        }
        ...

#include <iostream>

static const size_t NumCardsInDeck = 24;
static const size_t NumCardsPerHand = 5;
static const size_t NumPlayers = 4;

// removed 'cards' because we aren't using it.
const char* DECK[NumCardsInDeck] =
{
    "Ace of Spades", "Nine of Spades", "Ten of Spades", "Jack of Spades", "Queen of Spades", "King of Spades",
    "Ace of Hearts", "Nine of Hearts", "Ten of Hearts", "Jack of Hearts", "Queen of Hearts", "King of Hearts",
    "Ace of Clubs", "Nine of Clubs", "Ten of Clubs", "Jack of Clubs", "Queen of Clubs", "King of Clubs",
    "Ace of Diamonds", "Nine of Diamonds", "Ten of Diamonds", "Jack of Diamonds", "Queen of Diamonds", "King of Diamonds" 
};

int main()
{
    const char* hands[NumPlayers][NumCardsPerHand];
    enum { Player1, Player2, Player3, Player4 }; // For indexing the hands.

    std::cout << "We have " << NumPlayers << " hands of " << NumCardsPerHand << " cards." << std::endl;
    std::cout << "Total cards that will be dealt: " << NumPlayers * NumCardsPerHand << std::endl;

    for(size_t i = 0 ; i < NumCardsInDeck; ++i) // for the total amount of cards
    {
        if(i < 3)
        {
            hands[Player1][0] = DECK[i];
        }
        else if(i < 6)  // it's an else, so i > 2 is already implied.
        {
            hands[Player2][0] = DECK[i];
        }
        else
        {
            break;
        }
    }

    std::cout << "hands[0][0] = " << hands[0][0] << std::endl;
    std::cout << "hands[1][0] = " << hands[1][0] << std::endl;

    return 0;
}