c - 读入文件并在c中创建双链表

Question

所以我是 C 编码新手，在使用以下代码创建链接列表时遇到问题。我一直遇到的问题是 fscanf 每次读入内容时都会更改变量。所以我的头指针值不断变化。有没有办法来解决这个问题？谢谢!

经过一番讨论，我意识到这是因为结构体中的助记符是一个指针，所以 head 的助记符会发生变化，因为它只是指向指针。有没有办法在不改变结构本身的情况下解决这个问题？ (意思是将助记符留在struct Instr中作为指针)

void linkTypeInstr(struct InstrType *it, char *c, FILE *mfp){
    int count = 0;
    char type[2], mnemonic[11];
    uint32_t uid = 0, pretty = 0;
    struct Instr *head = NULL;
    struct Instr *ptr = NULL;
    /*read through the file in format*/
    while(fscanf(mfp, "%s %u %s %u ", type, &uid, mnemonic, &pretty) != NULL){
        if(head != NULL)
            printf("head: %s\n", head -> mnemonic);
        /*check if is the match type*/
        if(*type == *c){
            /*make a new struct instr for the item want to add*/
            struct Instr *temp = malloc(sizeof(struct Instr));
            memset(temp, 0, sizeof(struct Instr));
            temp -> uid = uid;
            temp -> pretty = pretty;
            temp -> mnemonic = mnemonic;
            temp -> next = NULL;
            temp -> prev = NULL;
            printf("temp: %s\n", temp -> mnemonic);
            printf("count: %d\n", count);
            /*check if list is empty, set ptr to head*/
            if(count == 0){
                head = temp;
                count++;
            }
            /*if list is not empty, find the place to put the item in alphabetical order*/
            else{
                ptr = head;
                printf("head: %s\n", head -> mnemonic);
                while(ptr != NULL){
                    /*if temp should come after ptr in the order*/
                    if(strcmp(ptr -> mnemonic, temp -> mnemonic) < 0){
                        if(ptr -> next == NULL){
                            ptr -> next = temp;
                            temp -> prev = ptr;
                            count++;
                            ptr = NULL;
                        }
                        else if(strcmp(temp -> mnemonic, ptr -> next -> mnemonic) < 0){
                            temp -> next = ptr -> next; 
                            ptr -> next -> prev = temp;
                            ptr -> next = temp;
                            temp -> prev = ptr;
                            count++;
                            ptr = NULL;
                        }
                        else 
                            /*if should be after ptr -> next*/
                            ptr = ptr -> next;
                    }
                    /*if temp should come before ptr in the order*/
                    else if(strcmp(temp -> mnemonic, ptr -> mnemonic) < 0){
                        if(ptr -> prev == NULL){
                            ptr -> prev = temp;
                            temp -> next = ptr;
                            head = temp;
                            count++;
                            ptr = NULL;
                        }
                        else if(strcmp(ptr -> prev -> mnemonic, temp -> mnemonic) < 0){
                            ptr -> prev -> next = temp;
                            temp -> prev = ptr -> prev;
                            ptr -> prev = temp;
                            temp -> next = ptr;
                            count++;
                            ptr = NULL;
                        }
                        else
                            /*if should be before ptr -> prev*/
                            ptr = ptr -> prev;
                    }
                }
            }
        }
    }
    it -> count = count;
    it -> head = head;
}


struct Instr {
        uint32_t uid; /* Unique identification bits */
        uint32_t pretty; /* The type of pretty print format this Instr is */
        char *mnemonic; /* The human readable mnemonic */
        struct Instr *next; /* Pointer for doubly linked list */
        struct Instr *prev; /* Pointer for doubly linked list */
};

struct InstrType {
        char type; /* Should be R, I, or J */
        size_t count; /* Length of Instr list */
        struct InstrType *next; /* Points to the next InstrType node */
        struct InstrType *prev; /* Points to the next InstrType node */
        struct Instr *head; /* Points to the first Instr node of this type */
};

我试图读取的文件看起来像这样:

r 00000020 add 3
r 00000021 addu 3
r 00000022 sub 3
r 00000023 subu 3
r 00000018 mult 2
r 00000019 multu 2
r 0000001a div 1
r 0000001b divu 1
r 00000010 mfhi 0
r 00000011 mthi 0
r 00000012 mflo 0
r 00000013 mtlo 0
r 00000000 sll 8
r 00000002 srl 8
r 00000003 sra 8
r 00000004 sllv 3
r 00000006 srlv 3
r 00000007 srav 3
r 00000024 and 3
r 00000025 or 3
r 00000026 xor 3
r 00000027 nor 3
r 0000002a slt 3
r 0000002b sltu 3
r 00000008 jr 0
r 00000009 jalr 2
r 0000000c syscall 5
i 20000000 addi 2
i 24000000 addiu 2
i 3c000000 lui 2
i 28000000 slti 2
i 2c000000 sltiu 2
i 30000000 andi 2
i 34000000 ori 2
i 38000000 xori 2
i 80000000 lb 4
i 84000000 lh 4
i 88000000 lwl 4
i 8c000000 lw 4
i 90000000 lbu 4
i 98000000 lwr 4
i a0000000 sb 4
i a4000000 sh 4
i a8000000 swl 4

当我运行此命令时，结果总是将我的 head ptr 更改为创建的新临时值:

temp: add
count: 0
head: addu
temp: addu
count: 1
head: addu
...

调用该函数的代码如下所示:

int main(int argc, char *argv[]){
    int c;
    int iFlag = 0, oFlag = 0;
    char mFileName[256] = "instruction_mapping.txt";
    char oFileName[256];
    char iFileName[256];
    extern char *optarg;
    FILE *mfp, *ifp, *ofp;

    /*create three struct instrtype nodes*/
    struct InstrType *itR = malloc(sizeof(struct InstrType));
    struct InstrType *itI = malloc(sizeof(struct InstrType));
    struct InstrType *itJ = malloc(sizeof(struct InstrType));

    memset(itR, 0, sizeof(struct InstrType));
    memset(itI, 0, sizeof(struct InstrType));
    memset(itJ, 0, sizeof(struct InstrType));

    /*link the struct instrtype together*/
    if(itR != NULL && itI != NULL && itJ != NULL){
        itR -> prev = NULL;
        itR -> next = itI;
        itI -> prev = itR;
        itI -> next = itJ;
        itJ -> prev = itI;
        itJ -> next = NULL;
    }

    /*set up instrtypes*/
    itR -> type = 'R';
    itI -> type = 'I';
    itJ -> type = 'J';

    /* parse arguments */
    while ((c = getopt(argc, argv, "m:i:o:h")) != -1){
        switch(c){
            case 'h':
                USAGE(argv[0]);
                return EXIT_SUCCESS;
            case 'm':
                strcpy(mFileName, optarg);
                break;
            case 'i':
                iFlag = 1;
                strcpy(iFileName, optarg);
                break;
            case 'o':
                oFlag = 1;
                strcpy(oFileName, optarg);
                break;
            default:
                USAGE(argv[0]);
                return EXIT_FAILURE;
        }
    }

    /*check -i and -o must be in argv*/
    if(iFlag == 1 && oFlag == 1){
        mfp = fopen(mFileName, "r");
        if(mfp == NULL){
            printf("Cannot open instruction mapping file\n");
            EXIT_FAILURE;
        }
        printf("mapping file: %s\n", mFileName);
        ifp = fopen(iFileName, "r");
        if(ifp == NULL){
            printf("Cannot open input file\n");
            EXIT_FAILURE;
        }
        printf("input file: %s\n", iFileName);
        ofp = fopen(oFileName, "w");
        if(ofp == NULL){
            printf("Error creating or writing file\n");
            EXIT_FAILURE;
        }
        printf("output file: %s\n", oFileName);

        /* make linked lists of instr in R, I, J instrtype */
        linkTypeInstr(itR, "r", mfp);
        linkTypeInstr(itI, "i", mfp);
        linkTypeInstr(itJ, "j", mfp);


        if(mfp != NULL)
            fclose(mfp);
        if(ifp != NULL)
            fclose(ifp);
        if(ofp != NULL)
            fclose(ofp);
    }   
    else{
        printf("Must have both input and output files\n");
        return EXIT_FAILURE;
    }
    free(itR);
    free(itI);
    free(itJ);
    return EXIT_SUCCESS;
}

Answer 1

你的问题是这一行:

temp -> 助记符 = 助记符；

事实上 temp->mnemonic 是一个指针，这意味着它将始终指向助记符数组中相同的 11 个字符。由于 head 是从 temp 分配的，因此 head->mnemonic 将指向相同的 11 个字符，这些字符将在下次调用 fscanf 时被覆盖。

解决方案是更改您的

结构指令{
uint32_t uid；/* 唯一标识位 */
uint32_t 漂亮；/* 该 Instr 的 pretty-print 格式类型 */
char *助记符；/* 人类可读的助记符 */
结构指令 *下一个;/* 双向链表指针 */
结构指令 *prev;/* 双向链表指针 */
};

到

结构指令{
uint32_t uid；/* 唯一标识位 */
uint32_t 漂亮；/* 该 Instr 的 pretty-print 格式类型 */
字符助记符[11]；/* 人类可读的助记符 */
结构指令 *下一个;/* 双向链表指针 */
结构指令 *prev;/* 双向链表指针 */
};

并用 strncpy 对其进行赋值:

strncpy(temp -> 助记符, 助记符, 11);