尽管定义为 1，但变量值过长

Question

当我使用 printf 语句获取它时，我的一个变量 dict2Length 返回了一个惊人的 1701996320。尽管我已经注释掉了任何可能增加其价值的东西，但这种情况仍然存在，这使我的困惑更加复杂。它最初被定义为 1。

这是我的代码。篇幅过长，我深表歉意。

#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]);
                        //printf("one\n");
                    }
                    for (k = 0; k < strlen(dictionary[word1].definition); k++) {
                        strcpy(&dictionary2[word2].definition[k], &dictionary[word1].definition[k]);
                        //printf("two\n");
                    }
                    //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]);

                            //printf("%d", word1);
                        }
                        //definition
                        for (k = 0; k <= strlen(&dictionary2->word[0]); k++) {
                            strcpy(&dictionary2[j+1].definition[k], &dictionary2[j].definition[k]);
                            //printf("two\n");
                            //printf("%d", word1);
                        }
                    }

                    for (k = 0; k < strlen(dictionary[word1].word); k++) {
                        strcpy(&dictionary2[word2].word[k], &dictionary[word1].word[k]);
                        //printf("three\n");
                        //printf("%d", word1);
                    }

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

    word2 = 0;
    printf("dict2Length = %d", dict2Length);
    //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

可能是因为您复制了错误的字符串并损坏了堆栈。您的循环看起来像是一次尝试复制一个字符，您遍历 i 遍历每个字符，但随后您对每个字符执行 strcpy 。 strcopy 将所有字符复制到 null 上，因此您无需自己执行循环。

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

我认为您可能打算做一些更像下面的事情，而不是没有按字符循环来复制字符串。

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

Answer 2

如果您尝试将 dictonary 中 word 的内容复制到 dictionary2 则以下代码

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

应该换成下面那个

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

Answer 3

花了小白才弄清楚你要做什么？您将 urnary 运算符与 struct 一起使用是没有意义的。我可能仍然没有 100% 正确，但您的所有代码似乎都是对结构进行排序的尝试。我不知道你是否有强迫你尝试手动排序的约束，但通常的方法是我们使用像qsort 这样的算法来为你排序结构。现在，您可以对整个结构进行排序，但这将首先对空元素进行排序。为避免此问题，请仅发送 qsort 包含单词的元素数量。确定填充元素数量的快速方法是检查words 中的第一个字符是否存在。结合以上所有内容，您的 dictionary 结构可以简化为：

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

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

int dictcompare (const void *a, const void *b)
{
    struct entry *sa = (struct entry *)a;
    struct entry *sb = (struct entry *)b;
    return strcmp (sa-> word, sb-> word);
}

int main (void) {

    size_t num_entries = 0;
    size_t i = 0;

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

    /* count the number of filled entries in dictionary */
    while (*dictionary[num_entries++].word);
    num_entries--;

    /* print the unsorted entries */
    printf ("\ndictionary:\n\n");
    for (i = 0; i < num_entries; i++)
        printf (" %-15s : %s\n", dictionary[i].word, dictionary[i].definition);

    /* sort the dictionary entries using qsort */
    qsort (dictionary, num_entries, sizeof (struct entry), dictcompare);

    /* print the unsorted entries */
    printf ("\ndictionary (sorted):\n\n");
    for (i = 0; i < num_entries; i++)
        printf (" %-15s : %s\n", dictionary[i].word, dictionary[i].definition);

    return 0;
}

输出

$ ./bin/struct_dictionary

dictionary:

 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

dictionary (sorted):

 aardvark        : a burrowing African mammal
 abyss           : a bottomless pit
 acumen          : mentally sharp; keen
 addle           : to become confused
 aerie           : a high nest
 affix           : to attach
 agar            : a jelly made of seaweed
 ahoy            : a nautical call of greeting
 aigrette        : an ornamental cluster of feathers
 ajar            : partially opened