分段错误 11，尽管已分配大量内存

Question

我运行遇到了一个奇怪的错误。当我编译我的代码时，它给我以下消息：

%i??
[R?
R?
?
Desktop/prog2
Terminal
51/sls2t0f16cd4dzl3640n4p2w0000gn/T/
private/tmp/com.apple.launchd.AJrzeyltFv/Render
ION=343.6
ER=Frank
Listeners
in:/usr/bin:/bin:/usr/sbin:/sbin:/usr/local/git/bin
ank
E=/Users/Frank
nk/Desktop/prog2

Segmentation fault: 11
logout

我知道这是内存问题。但是我给了dictionary2和原来的字典一样的内存，为什么不能编译出整个列表呢？

这是我的代码（我知道它有点长，但我觉得有必要传达正在发生的事情）：

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

struct entry
{
    char word[15];
    char definition[50];
};


void dictionarySort(struct entry dictionary[]) {
    int i, j, k, word1, word2, dict2Length = 1;
    bool bnf = false;
    struct entry dictionary2[100] = {{}};

    for (i = 0; i <= strlen(&dictionary->word[0]); i++) {
        strcpy(&dictionary2[0].word[i], &dictionary[0].word[i]);
    }


    i = 0;
    word1 = 1;
    word2 = 0;



    while (isalpha(dictionary[word1].word[0])) {

        while (i <= strlen(&dictionary->word[word1])) {
            //printf("%c", dictionary[word1].word[i]);
            if (dictionary[word1].word[i] == dictionary2[word2].word[i]) {
                i++;
                bnf = false;
            }
            else if (dictionary[word1].word[i] < dictionary[word2].word[i]) {
                //insert section to prevent back-and-forth cycling
                if (bnf == false) {
                    word2--;
                    bnf = true;
                }
                else { //(dictionary[word1].word[i] < dictionary[word2].word[i])
                    //open up new index by moving everything above up one, insert at word
                    for (j = dict2Length; j > word2; j--) {
                        //word
                        for (k = 0; k <= strlen(&dictionary2->word[0]); k++) {
                            strcpy(&dictionary2[j+1].word[k], &dictionary2[j].word[k]);
                        }
                        //definition
                        for (k = 0; k <= strlen(&dictionary2->word[0]); k++) {
                            strcpy(&dictionary2[j+1].definition[k], &dictionary2[j].definition[k]);
                        }
                    }

                    //for (k = 0; k < strlen(&dictionary1->word[word1]))
                    for (k = 0; k < strlen(dictionary[word1].word); k++) {
                        strcpy(&dictionary2[word2].word[k], &dictionary[word1].word[k]);
                    }
                    for (k = 0; k < strlen(dictionary[word1].definition); k++) {
                        strcpy(&dictionary2[word2].definition[k], &dictionary[word1].definition[k]);
                    }
                    dict2Length++;
                    break;
                }   
            }
            else {
                //insert section to prevent back-and-forth cycling
                if (bnf == false) {
                    word2++;
                    bnf = true;
                }
                else { //(dictionary[word1].word[i] < dictionary[word2].word[i])
                    //open up new index by moving everything above up one, insert at word
                    for (j = dict2Length; j > word2; j--) {
                        //word
                        for (k = 0; k <= strlen(&dictionary2->word[0]); k++) {
                            strcpy(&dictionary2[j+1].word[k], &dictionary2[j].word[k]);
                        }
                        //definition
                        for (k = 0; k <= strlen(&dictionary2->word[0]); k++) {
                            strcpy(&dictionary2[j+1].definition[k], &dictionary2[j].definition[k]);
                        }
                    }

                    for (k = 0; k < strlen(dictionary[word1].word); k++) {
                        strcpy(&dictionary2[word2].word[k], &dictionary[word1].word[k]);
                    }
                    for (k = 0; k < strlen(dictionary[word1].definition); k++) {
                        strcpy(&dictionary2[word2].definition[k], &dictionary[word1].definition[k]);
                    }
                    dict2Length++;
                    break;
                }
            }
        }
        word1++;
    }


    word2 = 0;

    for (i = 0; i < dict2Length; i++) {
        printf ("%s\n", dictionary2[i].word);
    }

}

int main (void) {
    struct entry dictionary[100] = 
    {{"aerie", "a high nest"},
    {"abyss", "a bottomless pit"},
    {"ahoy", "a nautical call of greeting"},
    {"addle", "to become confused"},
    {"aardvark", "a burrowing African mammal"},
    {"agar", "a jelly made of seaweed"},
    {"acumen", "mentally sharp; keen"},
    {"aigrette", "an ornamental cluster of feathers"},
    {"affix", "to attach"},
    {"ajar", "partially opened"}};
    dictionarySort(dictionary);
}

Answer 1

这一行的索引从后往前

strcpy(&dictionary2[0].word[i], &dictionary[0].word[i]);

应该是

strcpy(&dictionary2[i].word[0], &dictionary[i].word[0]);

甚至更好

strcpy(dictionary2[i].word, dictionary[i].word);

此外，您的循环 for (i...) 是基于 strlen(&dictionary->word[0])。您是否应该将数组条目的数量作为参数传递给 dictionarySort()？就目前而言，循环基于第一个字典条目的长度。

我必须继续调试排序。这太可怕了。只需使用 qsort().

Answer 2

您似乎无法计算字典长度。当你运行它时，它说长度类似于 1701996321，这似乎比它应该的长得多。然后，在最后一个 for 循环中，就在打印单词的末尾，您可能超出了字典的范围。注释掉 printf，您会发现错误消失了。我将从研究 dict2Lenght 开始。

for (i = 0; i < dict2Length; i++) {
    printf ("%s\n", dictionary2[i].word);
}

Answer 3

使用qsort

void dictionarySort(struct entry dictionary[]) {
    struct entry dictionary2[100] = {{"",""}};
    int i, n;

    for (i = 0; i < 100 && dictionary[i].word[0] != '[=10=]'; ++i){
        dictionary2[i] = dictionary[i];
    }
    n = i;

    qsort(dictionary2, n, sizeof(*dictionary2), strcmp);

    for (i = 0; i < n; ++i) {
        printf ("%s\n", dictionary2[i].word);
    }
}

分段错误 11，尽管已分配大量内存

Segmentation fault 11, despite plenty of memory being allocated

c

memory

string

structure