strcmp找不到标识符

如果在使用 `strcmp` 函数时出现找不到标识符的错误，可能是因为您没有包含 `string.h` 头文件。`strcmp` 函数在 `string.h` 头文件中声明，因此必须将其包含在代码中以使用该函数。您可以在代码中添加以下行来包含该头文件：

#include <string.h>

请注意，如果您正在使用 C++ 编写代码，则可以在代码中包含 `cstring` 头文件，该头文件提供了与 `string.h` 相同的功能：

#include <cstring>

希望这可以帮助您解决问题！

相关问题

用c语言编写程序：输入一个源程序（可有多行）（不包含头文件和宏定义）实现对源程序的关键字、标识符、运算符、界符和常量单词的信息提取，信息包含所处位置（行号、列号）、类别信息，存入一个结构体数组或链表中，并输出，其中标识符：用来表示各种名字，如变量名，数组名，函数名。标识符以字母或下划线开头，后面跟字母、数字、下划线的任意字符序列，不可以数字开头,标识符不能使用关键字。标识符的长度不得超过8个字符。

以下是我编写的程序，可以实现对源程序的关键字、标识符、运算符、界符和常量单词的信息提取，并存入一个结构体数组中，并输出：

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

#define MAX_IDENTIFIER_LEN 8

// 关键字表
char *keywords[] = {
    "auto", "break", "case", "char", "const", "continue", "default", "do", "double", "else",
    "enum", "extern", "float", "for", "goto", "if", "int", "long", "register", "return",
    "short", "signed", "sizeof", "static", "struct", "switch", "typedef", "union", "unsigned", "void",
    "volatile", "while"
};

// 运算符表
char *operators[] = {
    "+", "-", "*", "/", "%", "=", "==", "!=", ">", "<", ">=", "<="
};

// 界符表
char *delimiters[] = {
    "(", ")", "[", "]", "{", "}", ",", ";"
};

// 单词类型枚举
enum word_type {
    KEYWORD,
    IDENTIFIER,
    OPERATOR,
    DELIMITER,
    CONSTANT
};

// 单词信息结构体
struct word_info {
    int line_num;           // 所在行号
    int col_num;            // 所在列号
    enum word_type type;    // 单词类型
    char *value;            // 单词值
};

// 判断一个字符串是否为关键字
int is_keyword(char *str) {
    int i;
    for (i = 0; i < sizeof(keywords) / sizeof(char *); i++) {
        if (strcmp(str, keywords[i]) == 0) {
            return 1;
        }
    }
    return 0;
}

// 判断一个字符是否为运算符
int is_operator(char ch) {
    int i;
    for (i = 0; i < sizeof(operators) / sizeof(char *); i++) {
        if (ch == operators[i][0]) {
            return 1;
        }
    }
    return 0;
}

// 判断一个字符串是否为界符
int is_delimiter(char *str) {
    int i;
    for (i = 0; i < sizeof(delimiters) / sizeof(char *); i++) {
        if (strcmp(str, delimiters[i]) == 0) {
            return 1;
        }
    }
    return 0;
}

// 判断一个字符是否为数字
int is_digit(char ch) {
    return isdigit(ch);
}

// 判断一个字符是否为字母或下划线
int is_letter_or_underscore(char ch) {
    return isalpha(ch) || ch == '_';
}

// 从源代码中提取单词信息并存入结构体数组中
void extract_word_info(char *source_code, struct word_info *word_infos, int *word_count) {
    int line_num = 1;   // 当前行号
    int col_num = 1;    // 当前列号
    int i = 0;          // 当前字符索引
    int start_index;    // 单词起始位置
    int end_index;      // 单词结束位置
    char ch;            // 当前字符
    char *word_value;   // 单词值
    while (source_code[i] != '\0') {
        ch = source_code[i];
        if (ch == '\n') {   // 如果是换行符，更新行号和列号
            line_num++;
            col_num = 1;
        } else if (isspace(ch)) {   // 如果是空白字符，更新列号
            col_num++;
        } else if (is_operator(ch)) {   // 如果是运算符
            start_index = i;
            end_index = i + 1;
            word_value = malloc(2);
            word_value[0] = ch;
            word_value[1] = '\0';
            word_infos[*word_count].line_num = line_num;
            word_infos[*word_count].col_num = col_num;
            word_infos[*word_count].type = OPERATOR;
            word_infos[*word_count].value = word_value;
            (*word_count)++;
            col_num++;
            i++;
        } else if (is_letter_or_underscore(ch)) {   // 如果是字母或下划线
            start_index = i;
            end_index = i;
            while (is_letter_or_underscore(source_code[end_index + 1]) || is_digit(source_code[end_index + 1])) {
                end_index++;
            }
            word_value = malloc(end_index - start_index + 2);
            strncpy(word_value, source_code + start_index, end_index - start_index + 1);
            word_value[end_index - start_index + 1] = '\0';
            if (is_keyword(word_value)) {   // 如果是关键字
                word_infos[*word_count].line_num = line_num;
                word_infos[*word_count].col_num = col_num;
                word_infos[*word_count].type = KEYWORD;
                word_infos[*word_count].value = word_value;
                (*word_count)++;
            } else {   // 如果是标识符
                if (!isdigit(word_value[0]) && strlen(word_value) <= MAX_IDENTIFIER_LEN) {
                    word_infos[*word_count].line_num = line_num;
                    word_infos[*word_count].col_num = col_num;
                    word_infos[*word_count].type = IDENTIFIER;
                    word_infos[*word_count].value = word_value;
                    (*word_count)++;
                } else {
                    free(word_value);
                }
            }
            col_num += end_index - start_index + 1;
            i = end_index + 1;
        } else if (is_digit(ch)) {   // 如果是数字
            start_index = i;
            end_index = i;
            while (is_digit(source_code[end_index + 1])) {
                end_index++;
            }
            if (source_code[end_index + 1] == '.') {   // 如果是浮点数
                end_index++;
                while (is_digit(source_code[end_index + 1])) {
                    end_index++;
                }
            }
            word_value = malloc(end_index - start_index + 2);
            strncpy(word_value, source_code + start_index, end_index - start_index + 1);
            word_value[end_index - start_index + 1] = '\0';
            word_infos[*word_count].line_num = line_num;
            word_infos[*word_count].col_num = col_num;
            word_infos[*word_count].type = CONSTANT;
            word_infos[*word_count].value = word_value;
            (*word_count)++;
            col_num += end_index - start_index + 1;
            i = end_index + 1;
        } else if (is_delimiter(&source_code[i])) {   // 如果是界符
            start_index = i;
            end_index = i + strlen(&source_code[i]) - 1;
            word_value = malloc(end_index - start_index + 2);
            strncpy(word_value, source_code + start_index, end_index - start_index + 1);
            word_value[end_index - start_index + 1] = '\0';
            word_infos[*word_count].line_num = line_num;
            word_infos[*word_count].col_num = col_num;
            word_infos[*word_count].type = DELIMITER;
            word_infos[*word_count].value = word_value;
            (*word_count)++;
            col_num += end_index - start_index + 1;
            i = end_index + 1;
        } else {   // 其他字符
            col_num++;
            i++;
        }
    }
}

// 输出单词信息
void print_word_info(struct word_info *word_infos, int word_count) {
    int i;
    printf("%-10s%-10s%-15s%s\n", "Line", "Column", "Type", "Value");
    for (i = 0; i < word_count; i++) {
        printf("%-10d%-10d", word_infos[i].line_num, word_infos[i].col_num);
        switch (word_infos[i].type) {
            case KEYWORD:
                printf("%-15s", "Keyword");
                break;
            case IDENTIFIER:
                printf("%-15s", "Identifier");
                break;
            case OPERATOR:
                printf("%-15s", "Operator");
                break;
            case DELIMITER:
                printf("%-15s", "Delimiter");
                break;
            case CONSTANT:
                printf("%-15s", "Constant");
                break;
        }
        printf("%s\n", word_infos[i].value);
    }
}

int main() {
    char source_code[1000];   // 源代码
    struct word_info word_infos[1000];   // 单词信息结构体数组
    int word_count = 0;   // 单词数量
    printf("请输入源程序（可有多行）：\n");
    fgets(source_code, sizeof(source_code), stdin);
    extract_word_info(source_code, word_infos, &word_count);
    print_word_info(word_infos, word_count);
    return 0;
}

以上程序实现了对源程序的关键字、标识符、运算符、界符和常量单词的信息提取，并存入一个结构体数组中，并输出。你可以将源程序复制粘贴到程序中进行测试。

void readByLL(){ linkList->next = NULL; linkNode *p = linkList;linkNode *temp = p; if((filePath=fopen("InFile.txt","r"))==NULL){ perror("文件不存在或读取错误!"); exit(1); } while(fgets(buf,MAXSIZE,filePath)!=NULL){//逐行读取 len = strlen(buf); //获取长度 for(i=0;i<len+1;i++){ if(buf[i]>='a'&&buf[i]<='z'||buf[i]>='A'&&buf[i]<='Z'){ if(buf[i]>='A'&&buf[i]<='Z')buf[i] += 32; //转换小写 if(!flag_word)flag_word = true; //标识符转换 temp_word[j] = buf[i]; //临时单词变量赋值 j++; //当前单词长度++ }else{ linkNode *node = (LinkList)malloc(sizeof(linkNode)); node->next = NULL; if(flag_word){ flag_word=false; bool flag_equ=false; //等值标识符 while(p){ if(strcmp(p->word,temp_word)==0){p->count++;flag_equ=true;p = linkList;break;} temp = p;p = p->next; }p = temp; if(!flag_equ){strcpy(node->word,temp_word);node->count = 1;p->next = node;n++;} j = 0;p = linkList->next; }memset(temp_word, 0, sizeof(temp_word)); } } } for(p=linkList->next;p!=NULL;p=p->next) for(temp=p->next;temp!=NULL;temp=temp->next){ if(strcmp(p->word,temp->word)>0){ x = p->count;strcpy(temp_word,p->word); p->count = temp->count;strcpy(p->word,temp->word); temp->count = x;strcpy(temp->word,temp_word); } }memset(temp_word, 0, sizeof(temp_word)); fileWrite = fopen("OutFile2.txt","w");p=linkList->next;num = n;n = 0; while(p){fprintf(fileWrite,"%s %d\n",p->word,p->count);p=p->next;} }

这段代码是一个读取文件并统计单词出现次数的程序。主要思路是逐行读取文件内容，然后对每个单词进行处理，最终输出每个单词及其出现次数。

具体实现上，使用一个链表来保存每个单词及其出现次数，对于每个单词，先判断是否为字母，如果是则将其转换为小写并保存在一个临时变量中，否则将临时变量中的单词加入链表中，并清空临时变量。在将单词加入链表时，需要判断该单词是否已经在链表中出现过，如果已经出现过，则将其出现次数加1，否则将其加入链表中。

最后将链表按照单词出现次数从大到小排序，并将结果输出到文件中。