Memory leak detection caused errors - c

Question

Well basically I had memory leaks. So I wanted to fix them! added free () in some functions. Run valgrind and got successful message All leak memories fixed or smth like that! And after that I have got bunch of errors :( I THINK i have put free() right. It is easy to get confused because there are node as a pointer and node as a struct (look in file.h). Any help appreciated. Thank you. Sorry if this question is simple. i am beginner.....
code in file.h
struct node {
int value;
struct node * next;
};
typedef struct node List;
int is_empty(List *);
List *add_node(List *, int);
List *remove_node(List *, int);
List *create_node(int);
char *tostring(List *);
code in file.c
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "list.h"
#define STRSIZE 128 /*assume string representation fits*/
/* Return true if the list h is empty
* and false otherwise.
*/
int is_empty(List *h) {
return h == NULL;
}
/* Create a list node with value v and return a pointer to it
*/
List *create_node(int v) {
List *node = malloc(sizeof(List));
free(node);
node->value = v;
node->next = NULL;
return node;
}
/* Insert a new node with the value v at the
* front of the list. Return the new head of
* the list.
*/
List *add_node(List *h, int v) {
List *node = create_node(v);
node->next = h;
return node;
}
/* Remove the first node in the list h that
* has the value v. Return the head of the
* list.
*/
List *remove_node(List *h, int v) {
List *curr = h;
/* Handle the cases when list is empty or the value
* is found at the front of the list */
if (h == NULL) {
return h;
} else if (h->value == v) {
h = h->next;
return h;
}
/* Look for the value in the list (keeping the pointer to
* the previous element so that we can remove the right
* element) */
while (curr->next != NULL && curr->next->value != v) {
curr = curr->next;
}
if (curr->next == NULL) { /* v is not in list so do nothing */
return h;
} else { /* curr->next->value == v */
curr->next = curr->next->next;
return h;
}
}
/* Return a string representation of the list pointed to by h.
*/
char *tostring(List *h) {
char *str= malloc(STRSIZE);
char num[4]; /* assume integer has max. four digits*/
free(str);
str[0] = '\0';
while (h != NULL) {
sprintf(num, "%d", h->value);
strncat(str, num, STRSIZE - strlen(str) - 1);
h = h->next;
}
return str;
}

Answer 1

Possibly you want
temp = curr->next;
curr->next = curr->next->next;
free (temp);
In the current state of your code the remove_node is leaky (leaks the entire list actually, if you remove all the nodes).
Also, to stop memory leak in the tostring function, the caller of this function has the responsibility to free the string returned by tostring.

Answer 2

In your create_node(), why do you have a free()? You should remove that free().
In your remove_node(), you need to always return the head. I think the following recursive method should work. The recursive function will find the node to be deleted and return the next node. It returns the same node if nothing is deleted. Keeps recursing until a node with the value is found or end of the list. The main thing to check is, does it work when
Removing the head node
empty list
Removing the last node
Removing a middle node
The following code is not tested :-).
You mentioned you still have memory leak. As mentioned by Karthik, your toString() function allocates memory and it is up to the caller to free it. So make sure every time you call toString() function, a free() is called also. Otherwise you would be leaking memory.
List *remove_node(List *h, int v) {
List *retval = remove_recurse(h,v);
// if retval is different from head, means head is removed. return new head.
// Otherwise return old head.
return (retval!=h) ? retval : h;
}
List *remove_recurse(List *node, int v) {
if(node==NULL) return NULL;
List *retval = node; // default return current node
if(node!=NULL && node->value==v) { // need to remove node
retval = node->next; // return the next node
free(node); // delete node
}
else {
List *temp = remove_recurse(node->next,v);
// if next node was deleted, point to new node
if(node->next!=temp) node->next=temp;
}
return retval;
}

Answer 3

With this
List *node = malloc(sizeof(List));
free(node);
you allocate a node(List) then let node point to it, then you free what node is pointing to so after free it is pointing to some unallocated space somewhere in memory then you start assigning to that memory:
node->value = v;
node->next = NULL;
which causes undefined behavior, it is definitely wrong but will not be detected by the compiler.
remove free(node)
List *create_node(int v)
{
List *node = malloc(sizeof(List));
node->value = v;
node->next = NULL;
return node;
}
it is more readable if you keep the name of the struct the same as the typedef i.e.
typedef struct node {...} node;
instead of creating a new alias, use instead a better variable name e.g.
node* listStartOfNodes = NULL; // always initialize

Answer 4

1、this function is wrong.
List *create_node(int v) {
List *node = malloc(sizeof(List));
free(node);
node->value = v;
node->next = NULL;
return node;
}
Why do you free(node)? please remove this free(node);.
And the same fault in this function, please remove free(str);
char *tostring(List *h) {
char *str= malloc(STRSIZE);
char num[4]; /* assume integer has max. four digits*/
free(str);
str[0] = '\0';
while (h != NULL) {
sprintf(num, "%d", h->value);
strncat(str, num, STRSIZE - strlen(str) - 1);
h = h->next;
}
return str;
}
2、you should modify this function:
List *remove_node(List *h, int v) {
List *curr = h;
List* freeNode = NULL;
/* Handle the cases when list is empty or the value
* is found at the front of the list */
if (h == NULL) {
return h;
} else if (h->value == v) {
freeNode = h;
h = h->next;
free(freeNode);
return h;
}
/* Look for the value in the list (keeping the pointer to
* the previous element so that we can remove the right
* element) */
while (curr->next != NULL && curr->next->value != v) {
curr = curr->next;
}
if (curr->next == NULL) { /* v is not in list so do nothing */
return h;
} else { /* curr->next->value == v */
freeNode = curr->next;
curr->next = curr->next->next;
free(freeNode);
return h;
}
}

Answer 5

In the function remove_node
List *remove_node(List *h, int v)
{
List *curr = h,*prev;
/* Handle the cases when list is empty or the value
* is found at the front of the list */
if (h == NULL) {
return h;
} else if (h->value == v) {
h = h->next;
free(curr);
return h;
}
while (curr->next != NULL && curr->next->value != v) {
curr = curr->next;
}
if (curr->next == NULL) { /* v is not in list so do nothing */
return h;
} else { /* curr->next->value == v */
prev = curr->next;
curr->next = curr->next->next;
free(prev);
return h;
}
}
You should free the memory when you no longer want that node in your case while removing the node you should free the memory.
And in the function tostring don't free the memory you just allocated free the memory in the called function after the str is no more used or required.