c - 试图解决C程序中的段错误

Closed. This question is off-topic。它当前不接受答案。












                            想改善这个问题吗？ Update the question，所以它是on-topic，用于堆栈溢出。

                        在10个月前关闭。



我是一名学生，并且获得了我已经从事了一周的该程序。每当我运行该程序时，我都会遇到分段错误问题，我进行了更改并尝试了几乎所有内容，在互联网上阅读了很多内容，没有任何帮助。我一直在尝试使用调试器来解决这个问题！

我认为这是我在eurovisionAddState()中分配内存的方式，但是我更改了很多次，没有任何效果...

这是我的程序：

#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include <stdbool.h>
#include <string.h>

#define NUM_OF_JUDGE_VOTES 10
#define NOT_FOUND -1

typedef enum eurovisionResult_t {
    EUROVISION_NULL_ARGUMENT,
    EUROVISION_OUT_OF_MEMORY,
    EUROVISION_INVALID_ID,
    EUROVISION_INVALID_NAME,
    EUROVISION_STATE_ALREADY_EXIST,
    EUROVISION_STATE_NOT_EXIST,
    EUROVISION_JUDGE_ALREADY_EXIST,
    EUROVISION_JUDGE_NOT_EXIST,
    EUROVISION_SAME_STATE,
    EUROVISION_SUCCESS
} EurovisionResult;

//Structs:
struct country_t {
    int *ID;
    char *CountryName;
    char *SongName;
};

typedef struct country_t *Country;

//Nodes
typedef struct CountryNode_t {
    Country data;
    struct CountryNode_t *next;
    struct CountryNode_t *before;
} *CountryNode;

typedef struct eurovision_t {
    CountryNode Countries;
} *Eurovision;

//========
//Functions:
Eurovision eurovisionCreate() {
    Eurovision euro = (Eurovision)malloc(sizeof(*euro));
    euro->Countries = (CountryNode)malloc(sizeof(struct CountryNode_t));
    return euro;
}

static Eurovision setupEurovision() {
    Eurovision eurovision = eurovisionCreate();
    assert(eurovision);
    return eurovision;
}

CountryNode countryGetFirst(CountryNode cn) {
    while (cn->before) {
        cn = cn->before;
    }
    return cn;
}

bool countryNodeExists(CountryNode c, int ID) //Returns TRUE if country with the given ID exists,
{                                            // and FALSE if country with the given ID doesn't exist
    CountryNode cn = countryGetFirst(c);
    while (cn) {
        if (*(cn->data->ID) == ID) {
            return true;
        }
        cn = cn->next;
    }
    return false;
}

int countryNodeSize(CountryNode countryNode) //Returns the amount of countries in countryNode
{
    CountryNode cn = countryGetFirst(countryNode);
    int size = 0;

    while (cn) {
        size++;
        cn = cn->next;
    }
    return size;
}

void countryNodePut(CountryNode countryNode,Country country) //Puts country inside the correct
{                                                            //place (via ID comparison) in countryNode
    //if country is first
    if (countryNodeSize(countryNode) == 0) {
        countryNode = (CountryNode)malloc(sizeof(struct CountryNode_t));
        countryNode->before = NULL;
        countryNode->next = NULL;
        countryNode->data = country;
        return;
    }

    CountryNode new_country_node = (CountryNode)malloc(sizeof(struct CountryNode_t));
    new_country_node->data = country;

    //If ID is before First
    CountryNode first = countryGetFirst(countryNode);
    if (*(first->data->ID) > *(country->ID)) {
        new_country_node->next = first;
        new_country_node->before = NULL;
        first->before = new_country_node;
        return;
    }

    //check if the country exists, and replace the data
    if (countryNodeExists(countryNode, *(country->ID))) {
        CountryNode cn = countryGetFirst(countryNode);
        while (cn) {
            if (*(cn->data->ID) == *(country->ID)) {
                cn->data = country;
                return;
            }
            cn = cn->next;
        }
    }

    //place it in its place
    CountryNode cn = countryGetFirst(countryNode);
    while (cn->next) { //cn->next so we wouldnt try to read from a null
        if (*(cn->data->ID) < *(country->ID) && *(cn->next->data->ID) > *(country->ID)) {
            cn->next->before = new_country_node;
            new_country_node->before = cn;
            new_country_node->next = cn->next;
            cn->next = new_country_node;
            return;
        }
    }

    //got here if countryNode should be last
    cn->next = new_country_node;
    new_country_node->before = cn;
}

bool checkInvalidName(const char *name) {
    int i = 0;
    while (*(name + i) != '\0') {
        if ((*(name + i) < 'a' || *(name + i) > 'z') && *(name + i) != ' ')
            return true;
        i++;
    }
    return false;
}

EurovisionResult eurovisionAddState(Eurovision eurovision, int stateId,
                                    const char *stateName,
                                    const char *songName)
{   //CHECK IF stateName IS VALID
    if (checkInvalidName(stateName))
        return EUROVISION_INVALID_NAME;
    //----
    //CHECK IF stateId IS POSITIVE
    if (stateId < 0)
        return EUROVISION_INVALID_ID;
    //----
    //CHECK IF THE SAME STATE EXIST
    if (countryNodeExists(eurovision->Countries, stateId))
        return EUROVISION_STATE_ALREADY_EXIST;
    //----

    Country state = (Country)malloc(sizeof(struct country_t));
    if (!state) {
        return EUROVISION_OUT_OF_MEMORY;
    }

    state->ID = (int *)malloc(sizeof(int));
    *(state->ID) = stateId;
    state->CountryName = (char*)malloc(sizeof(char) * strlen(stateName) + 1);
    strcpy(state->CountryName, stateName);
    state->SongName = (char *)malloc(sizeof(char) * strlen(songName) + 1);
    strcpy(state->SongName, songName);

    countryNodePut(eurovision->Countries, state);

    /*  //TEST - DELETE THIS
    Country stateNew = countryNodeGet(eurovision->Countries, stateId);
    printf("eurovisionAddState: after mapPut-Cname=%s,Sname=%s,id=%d\n",(stateNew->CountryName), (stateNew->SongName), *(stateNew->ID));
    //----*/

    return EUROVISION_SUCCESS;
}

int main() {
    printf("Starting Test\n");
    Eurovision eurovision = setupEurovision();
    printf("After setupEurovision()\n");
    eurovisionAddState(eurovision, 1, "malta", "chameleon");
    printf("After eurovisionAddState of Malta\n");
    eurovisionAddState(eurovision, 2, "croatia", "the dream");
    eurovisionAddState(eurovision, 3, "russia", "scream");
    eurovisionAddState(eurovision, 4, "moldova", "stay");
    eurovisionAddState(eurovision, 5, "cyprus", "replay");
    eurovisionAddState(eurovision, 6, "spain", "la venda");
    eurovisionAddState(eurovision, 7, "italy", "soldi");
    eurovisionAddState(eurovision, 8, "france", "roi");
    eurovisionAddState(eurovision, 9, "germany", "sister");
    eurovisionAddState(eurovision, 10, "united kingdom", "bigger than us");
    eurovisionAddState(eurovision, 11, "armenia", "walking out");
    eurovisionAddState(eurovision, 12, "austria", "limits");
    eurovisionAddState(eurovision, 13, "ireland", "twenty two");
    eurovisionAddState(eurovision, 14, "netherlands", "arcade");
    eurovisionAddState(eurovision, 15, "sweden", "too late for love");
    return 0;
}

最佳答案

我一直在尝试使用调试器来解决这个问题！

调试器是诊断这种情况的重要工具，但是您仍然必须认真考虑代码的工作方式，以便了解调试器的内容。要记住的一个有用想法是，每次崩溃都是由某个特定指令*引起的，您的工作是找到该指令，然后弄清楚如何到达那里。

每当我运行此程序时，我都会遇到此细分错误问题

好的，那条指令导致分段错误？您的调试器应该能够将您指向该行。我的说问题出在这里：

while (cn->before)

它还告诉我我们如何到达这一点以及问题是什么：

* thread #1, queue = 'com.apple.main-thread', stop reason = EXC_BAD_ACCESS (code=EXC_I386_GPFLT)
  * frame #0: 0x000000010000064c DeleteThis`countryGetFirst(cn=0x8b480850ff078b48) at main.c:65
    frame #1: 0x0000000100000688 DeleteThis`countryNodeExists(c=0x0000000102905f60, ID=1) at main.c:74
    frame #2: 0x0000000100000a1e DeleteThis`eurovisionAddState(eurovision=0x0000000102908750, stateId=1, stateName="malta", songName="chameleon") at main.c:182
    frame #3: 0x0000000100000b76 DeleteThis`main at main.c:212
    frame #4: 0x00007fff617253d5 libdyld.dylib`start + 1
    frame #5: 0x00007fff617253d5 libdyld.dylib`start + 1

（“ DeleteThis”只是我为该项目指定的名称-提醒我，我不需要在接下来的20分钟内保存它。此外，我删除了一些多余的空行，因此我的行号可能会赢得与您不匹配。）

这里重要的是，我们正在查看堆栈，并且可以看到countryGetFirst由countryNodeExists调用，而eurovisionAddState又由main调用，而main从eurovision调用。好的，接下来我们需要知道相关线路为什么崩溃。分段错误通常意味着您正在尝试取消引用错误的指针。确实，崩溃的行确实取消了某些指针的引用，但这不好吗？让我们找出它的来源...

您的setupEurovision函数首先设置一个变量eurovision->Countries，如下所示：

Eurovision eurovision = setupEurovision();

那么eurovisionAddState是做什么的呢？它只是为Eurovision结构分配了一些空间，然后分配了另一个块并使eurovisionAddState指向它：

Eurovision euro=(Eurovision)malloc(sizeof(*euro));
euro->Countries=(CountryNode)malloc(sizeof(struct CountryNode_t));
return euro;

到目前为止看起来还好吧？接下来，那件事怎么办？好吧，接下来您添加一个国家：

eurovisionAddState(eurovision, 1, "malta", "chameleon");

为此，countryNodeExists调用：

if(countryNodeExists(eurovision->Countries,stateId))

这很有趣，因为崩溃发生时eurovision->Countries和countryNodeExists都在调用堆栈中，而您只是分配了c，那么如果我们查看eurovision->Countries会发生什么呢？好吧，它要做的第一件事就是调用崩溃的函数：

CountryNode cn = countryGetFirst(c);

它在此处传递的countryGetFirst恰恰是调用方中的cn。嗯...继续前进。 c中有什么？

while (cn->before)

嗯为什么会崩溃？此处的eurovision->Countries在调用方中称为cn，在先前的调用方中为eurovision->Countries，因此我们可以从main一直追溯malloc到malloc。您认为那里有什么？记住，您是这样创建的：

(CountryNode)malloc(sizeof(struct CountryNode_t));

（此外：您真的不应该转换before的结果。在SO上搜索此处以找出原因。）

因此，您使用CountryNode创建了该对象。它有什么价值？您实际上并不知道该块中的内容，只知道该块的地址，并且尚未在该地址保存任何内容。因此，有两种可能：它要么为零，要么为非零。非零的赔率非常好，那么接下来会发生什么呢？好吧，您执行循环的主体，因此您可以执行以下操作：

cn = cn->before;

好，所以此cn的before成员中的内容现在都在CountryNode中。同样，我们不知道块中有什么，但是可以很安全地假定此cn值不是指向另一个cn的指针，因为您尚未在其中保存任何内容。所以现在是一些随机值。您到达了循环的结尾，由于是循环，因此您需要重复：

while (cn->before)

嗯...现在您要取消引用中的随机值，这时您会遇到段错误，因为不允许您从任何地方读取内存。

现在，我已经引导您完成了整个过程，以说明思考过程。但是，即使您不立即了解问题，您也应该能够使用调试器执行相同的操作……您始终可以在您知道问题发生之前的某个时间点设置断点，然后逐步执行说明一次一次，直到您遇到错误。您现在应该这样做，以帮助您自己真正地了解和理解该问题。完成后，我相信您将能够找到解决方法。

祝好运！

*为此，请在他的著作How to Write Macintosh Software: The Debugging Reference for the Macintosh中向Scott Knaster致谢。

关于c - 试图解决C程序中的段错误，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/55989470/

上一篇：C:赋值运算符是否深复制？

下一篇：c - 重复完全相同的代码段 1000 次而不循环

相关文章：

c++ - 从 C++ 析构函数调用自定义免费 C 例程？

c - 如何为函数中的指针分配内存

c - unix shell 开发中的 Tab 完成功能

c - 给定数组，在偶数索引上确保它向上，在奇数索引上确保它向下

c - TCP server 可以同时处理两个不同的client写请求而不会互相阻塞

c - 增加指向 char 的指针的左值？

c - scanf() 函数不起作用？

c - 使用写入或异步安全函数从信号处理程序打印 int

objective-c - 为什么数组按引用传递，而结构在 C 中隐式按值传递？

c - 如何验证实数