1

我刚刚开始学习 C 语言，但我的一个程序遇到了问题。

执行时出现错误：“非法指令 4”：./dictionary large.txt

Large.txt 是一个包含 143091 个按字母顺序排列的单词的文件，每个单词都从一个新行开始。我正在尝试将它们全部加载到哈希表中，如果所有单词都成功加载，则返回 true。

如果 bool load() 中的代码在 int main 中并且 load() 不存在，则此代码对我有用。但是，一旦我将它放在 load() 函数中并从 main 调用它，就会出现错误。

我会很感激这方面的帮助，因为非法指令的线程并不多。

这是我的代码：

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

// Maximum length for a word
// (e.g., pneumonoultramicroscopicsilicovolcanoconiosis)
#define LENGTH 45

// Number of letters in the english alphabet
#define ALPHABET_LENGTH 26

// Default dictionary
#define DICTIONARY "large.txt"

// Represents a node in a hash table
typedef struct node
{
    char word[LENGTH + 1];
    struct node *next;
} node;

// Number of buckets in hash table
const unsigned int N = ALPHABET_LENGTH;

// Hash table
node *table[N];

// Load function
bool load(char *dictionary);

// Hash function
int hash(char *word);

int main(int argc, char *argv[])
{
    // Check for correct number of args
    if (argc != 2 && argc != 3)
    {
        printf("Usage: ./speller [DICTIONARY] text\n");
        exit(1);
    }

    // Determine which dictionary to use
    char *dictionary = (argc == 3) ? argv[1] : DICTIONARY;

    bool loaded = load(dictionary);

    // TODO: free hashtable from memory

    return 0;
}

bool load(char *dictionary)
{
    // Open dictionary for reading
    FILE *file = fopen(dictionary, "r");
    if (file == NULL)
    {
        printf("Error 2: could not open %s. Please call customer service.\n", dictionary);
        exit(2);
    }

    // Initialize array to NULL
    for (int i = 0; i < N; i++)
        table[i] = NULL;

    // Declare and initialize variables
    unsigned int char_count = 0;
    unsigned int word_count = 0;
    char char_buffer;
    char word_buffer[LENGTH + 1];
    int hash_code = 0;
    int previous_hash_code = 0;

    // Declare pointers
    struct node *first_item;
    struct node *current_item;
    struct node *new_item;

    // Is true the first time the while loop is ran to be able to distinguish between hash_code and previous_hash_code after one loop
    bool first_loop = true;

    // Count the number of words in dictionary
    while (fread(&char_buffer, sizeof(char), 1, file))
    {

        // Builds the word_buffer by scanning characters
        if (char_buffer != '\n')
        {
            word_buffer[char_count] = char_buffer;

            char_count++;
        }
        else
        {
            // Increases word count each time char_buffer == '\n'
            word_count += 1;

            // Calls the hash function and stores its value in hash_code
            hash_code = hash(&word_buffer[0]);

            // Creates and initializes first node in a given table index
            if (hash_code != previous_hash_code || first_loop == true)
            {
                first_item = table[hash_code] = (struct node *)malloc(sizeof(node));
                if (first_item == NULL)
                {
                    printf("Error 3: memory not allocated. Please call customer service.\n");
                    return false;
                }

                current_item = first_item;
                strcpy(current_item->word, word_buffer);
                current_item->next = NULL;
            }
            else
            {
                new_item = current_item->next = (struct node *)malloc(sizeof(node));
                if (new_item == NULL)
                {
                    printf("Error 4: memory not allocated. Please call customer service.\n");
                    return false;
                }

                current_item = new_item;
                strcpy(current_item->word, word_buffer);
                current_item->next = NULL;
            }

            // Fills word buffer elements with '\0'
            for (int i = 0; i < char_count; i++)
            {
                word_buffer[i] = '\0';
            }

            // Signals the first loop has finished.
            first_loop = false;

            // Clears character buffer to keep track of next word
            char_count = 0;

            // Keeps track if a new table index should be initialized
            previous_hash_code = hash_code;
        }
    }

    return true;
}

// Hash in order of: 'a' is 0 and 'z' is 25
int hash(char *word_buffer)
{
    int hash = word_buffer[0] - 97;

    return hash;
}

先感谢您！

克里斯

4

1 回答 1

0

您应该使用node *table[ALPHABET_LENGTH];声明table而不是node *table[N];

常量宏和变量之间存在区别const，宏可以在常量表达式中使用，例如根据您的用例绑定的全局数组，而const变量不能。

正如您在此处看到的，您说您正在使用的编译器 gcc，没有编译器标志，发出一条错误消息：

error: variably modified 'table' at file scope

您可以在“static const”、“#define”和“enum”中阅读更多关于这些差异和用例的信息，它有更多的主题，比如staticand enum，但是很好地理解了这些概念之间的差异。

于 2021-02-21T11:15:52.267 回答