释放内存时出现分段错误

Question

I tried to make a self-made program for lists. So, I created some basic stuff like creating the list, adding new nodes, showing them, and deleting all the existing nodes in the list.

However, when I put in my list more than 27 elements, it throws me a segmentation fault error while freeing the memory. By the way, when I add like 26 or smaller number of them, it works great. Maybe stack is overflowed or something like that, I really have no idea.

PS don't tell me that I`m developing a bike, in this way, making something by myself first, I understand things better:)

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

typedef struct node{
    struct node * next;
    int value;
} node;

int addNode(int position,int value, node ** head,int * size){
    int i = 2;
    node * curNode = *head;
    if(position > *size) return;
    while(i <= *size){
        if(position == 1){
            node * adress = *head;
            *head = (node*) malloc(sizeof(node*));
            (*head)->next = adress;
            (*head)->value = value;
            break;
        }

        else if(i == position){
            node * adress = curNode->next;
            curNode->next = (node*) malloc(sizeof(node*));
            curNode = curNode->next;
            curNode->next = adress;
            curNode->value = value;
            break;
        }
        else{
            curNode = curNode->next;            
            ++i;            
        }       
    }   
    ++(*size);      
    return;     
}

void showList(node * head, int size){
    int i; node * currentNode = head;
    for(i = 0; i < size; ++i){
        printf(" %d , next adress: %p |\n", currentNode->value, currentNode->next);
        currentNode = currentNode->next;
    }
    printf("\n");
}

void cleanList(node * head, int size){
    int i;
    node * curNode = head; node * nextToDelete = NULL;
    for(i = 0; i < size; ++i){
        nextToDelete = curNode->next;
        free(curNode);
        curNode = nextToDelete;
    }
}

int main() {
    node * head = (node*) malloc(sizeof(node*)); //saving head adress to know where the list starts
    head->value = 1; //set head value as "1"    
    int i, size;    
    node * currentNode = head; //pointer which points to a current node     
    for(i = 0; i < 5; ++i){         
        node * adress = (node*) malloc(sizeof(node*)); //variable which saves new node`s adress
        currentNode->next = adress; //set this new nod`s adress to previous node`s "next" parametr      
        currentNode = adress; //set new node`s adress to a current node 
        currentNode->value = i+2; ///set value for this node    
    }   
    size = 6;       
    addNode(2, 15, &head, &size);  
    showList(head, size);
    showList(head, size);  
    cleanList(head, size);
    return 0;
}

Answer 1

You are allocating memory incorrectly.

Notice these lines:

*head = (node*) malloc(sizeof(node*));

and

curNode->next = (node*) malloc(sizeof(node*));

You are allocating memory for a pointer to struct node instead of the actual struct.
Notice the sizeof function - you pass it the wrong parameter!

Your structure contains an int and a pointer. Those are usually the same size.
But you only allocate memory for a pointer, so, you allocate half the structure.

This will cause you to call free on an invalid address at some point. It is a miracle your program only crashed during free operation, it should have crashed much sooner.