釋放結構中的字符串時出現分段錯誤-C

Question

我長期以來一直陷入細分錯誤。 我聲明了一個帶有字符串指針的結構。 我編寫了兩個函數，創建和刪除以操縱值。 結構如下：

#include "filename.h"  
//*in filename.h:* typedef struct linkNode linkNode_t;

struct linkNode{
    struct linkNode *next;
    char *value;
};

create函數將首先為該節點分配內存，然后為該值分配內存，然后將輸入值復制到value字段中：

linkNode_t* create(char* stuff){
    linkNode_t *ptr=malloc(sizeof(linkNode_t));
    if(ptr==NULL){
        printf("malloc failure");
        return NULL;
    }
    char* tempvalu=malloc(sizeof(char)*strlen(stuff)+1);
    if(tempvalu==NULL){
        printf("malloc failure");
        return NULL;
    }
    strcpy(tempvalu,stuff);
    ptr->next=NULL;
    ptr->value=tempvalu;
    return ptr;
}

一個函數用於將節點插入到鏈表中：

linkNode_t* insertLast(linkNode_t* start, linkNode_t* newNode){
    linkNode_t* current=start;
    while(current->next!=NULL){
        current=current->next;
    }
//now current points to the last element in the linked list
    current->next=newNode;
    return start;
}

導致我出現問題的部分如下：

linkNode_t* removebyValue(linkNode_t* start, char* valu){
/**removes the first instance of a node with a certain value. Return *start after     removing.
    if linked list becomes empty, return NULL*/

    linkNode_t *current=start;
    linkNode_t *previous=start;
    while(current!=NULL){
        if(strcmp(valu,current->value)==0) {//found the node to delete
            if(current==start){//removing the head
                linkNode_t* retvalue= current->next;
                free(current->value);
                free(current);
                return retvalue;
            }
            else{   //removing other elements in the linked list
                previous->next=current->next;
                free(current->value);
                free(current);
                return start;
            }
        }
        else{
            previous=current;
            current=current->next;
        }
    }
    return start;
}

在Main中，我創建了一個包含兩個元素1和2的鏈接列表，並嘗試在發生分段錯誤時釋放元素1。

int main(){
    linkNode_t *pt1=create("1");
    pt1=insertLast(pt1,create("2"));
    removebyValue(pt1,"1"); //Causes seg fault. If I replace "1" by "2" nothing happens 

有人可以對此提出建議嗎？ 提前致謝

編輯：我放所有可能相關的代碼，因為有人說我放的部分沒有錯誤

Answer 1

我認為您在適當地維護啟動指針的同時，考慮了刪除節點的問題。 考慮一種希望更簡單的方法。

typedef struct node_t 
{
    struct node_t* next;
    char* value;
} node_t;

node_t* remove(node_t *start, const char* valu)
{
    node_t* current=start;
    node_t* prev=NULL;

    while(current && strcmp(current->value, valu))
    {
        prev = current;
        current = current->next;
    }

    if (current)
    {
        if (prev) // we're not deleting start node
            prev->next = current->next;

        else      // we *are* deleting start node
            start = current->next;

        // now the node is unlinked. remove it.
        free(current->value);
        free(current);
    }
    return start;
}

Answer 2

這是一個替代的測試代碼，可以很好地工作，搶劫一下，看看是否有幫助。 另外，您可以添加

typedef struct node_t {
    struct node_t* next;
    char* value;
} node;

這看起來更容易理解，但這不是因為typedef的性質令人困惑。 我強烈建議您看一看https://github.com/torvalds/linux/blob/master/Documentation/CodingStyle這是linux內核的編碼風格，它非常簡短，簡單，不是特別的法律，但是值得注意的是...

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

struct node_t {
    struct node_t* next;
    char* value;
};

struct node_t* create(const char* istr) 
{
    struct node_t* ptr = (struct node_t*)malloc(sizeof(struct node_t));
    char* tmp = (char*)malloc(sizeof(char) * (strlen(istr) + 1));

    strcpy(tmp, istr);
    ptr->next = 0;
    ptr->value = tmp;
    return ptr;
}

struct node_t* remove(struct node_t* start, const char* value)
{
    struct node_t* current = start;
    struct node_t* prev = start;

    while (current != 0) {
        if (!strcmp(value, current->value)) {
            if (current == start) {
                struct node_t* retval = current->next;
                free(current->value);
                free(current);
                return retval;
            } else {
                /* nothing happens */
                return 0;
            }
        }
    }
}

int main(const int argc, const char** argv)
{
    struct node_t* pt = create("1");
    printf("%s\n", pt->value);
    pt->next = create("2");
    printf("%s\n", pt->next->value);
    remove(pt, "1");    

    return 0;
}