realloc() in c.. printing junk value

Question

i have uploaded all of the code.. this is work in progress.. please check for realloc() because if i dont reach the condition for realloc() everything works fine...Thanks evry1..

  // contactinfo.h--  header file 
  #ifndef _ELEMENT_H

  #define _ELEMENT_H

  typedef struct ContactInfo ContactInfo;

  struct ContactInfo{
    char Name[30];

    char email_id[50];

    int phon_num;

  };


typedef ContactInfo **ContactList;

 #endif 

 //contactops.h

  #include "contactInfo.h"

ContactList createCL(int size);

void addContact(ContactList clist1, ContactList clist2, ContactInfo ci, int size);

ContactInfo *findByName(ContactList cl, char *name);

ContactInfo *findByNumber(ContactList cl, int num);

void deleteContactByName(ContactList cl, ContactList c2, char *name);

void deleteContactByNumber(ContactList cl, ContactList c2, int num);

void printContacts(ContactList cl);

void Merge_Sort(int hi, int mid, int lo, ContactList c);

void Merge(int hi , int lo, ContactList c);

//contactopsarr.c #include

 #include <string.h>

 #include <stdlib.h>

 #include "contactInfo.h"

 #include "contactOps.h"


int counter =0;                     

int buff_size = 5;                  //pre defined Size

ContactList arr_name;               //to hold the pointers to the locations of 
the shared data by name

ContactList arr_num;                //to hold the pointers to the locations of the shared data by number

ContactInfo *list ;                 // to hold the shared date

int main (){

    char search_name[20];           //buffer to hold the name to be searched

    int search_numb;                //buffer to hold the number to be searched
    arr_num = createCL(buff_size);  

    arr_name = createCL(buff_size);

    /************************* Allocation Of the Shared Data *******************************/

    list = malloc(buff_size * sizeof(ContactInfo));

    if(list == NULL){
        printf("Memmory Allocation Of the shared Data failed..\n");
    }

    /************************ Allocation Completed *****************************************/


    char choice;                    //to hold "y" or "n"

    printf("Do you want to Continue...");

    scanf(" %c",&choice);

    int option;                     //to hold Choice number to be selected
    ContactInfo ci;                 //buffer to hold the information to be added

    while(choice == 'Y'|| choice=='y')
    {
        printf("\n1.Add Contact\n2.FIND Contact by NAME\n3.FIND Contact by NUMBER\n4.DELETE contact by NAME\n5.DELETE contact by NUMBER\n6.PRINT contact\n");
        printf("Enter Your Option..\n");
        scanf(" %d",&option);
        switch(option)
        {
            case 1: printf("Enter the Name:\n");
                    scanf(" %s",&ci.Name);
                    printf("Enter the Number:\n");
                    scanf(" %d",&ci.phon_num);
                    printf("Enter the Email-id:\n");
                    scanf(" %s",&ci.email_id);
                    addContact(arr_num , arr_name, ci, buff_size);
                    break;

        /*  case 2: printf("Enter the name to be Searched..\n");
                    scanf(" %s",&search_name);
                    findByName(list, search_name);
                    break;

            case 3: printf("Enter the number to be Searched..\n");
                    scanf(" %s",&search_numb);
                    findByNumber(list,search_numb );
                    break;

            case 4: break;

            case 5: break;
*/
            case 6: printContacts(arr_num);
                    break;  

            default : printf("Enter a Correct Choice...\n");

        }

    }

}



ContactList createCL(int size){
    ContactList temp = malloc(buff_size * sizeof(ContactInfo *));
    return temp;
}

void addContact(ContactList clist1, ContactList clist2, ContactInfo ci, int size)
{   

    printf("Val of counter : %d\n",counter);
    printf("Val of buff_size : %d\n", size);
    if((counter+1)>=size)
    {
        /*realloc(list, (buff_size +5)*sizeof(ContactInfo ));
        //ContactInfo *temp = malloc((size+5)*sizeof(ContactInfo));
        if(list == NULL){
            printf("Extended Memory Allocation(0) Failed..Quiting..");
            exit(1);
        }
        /*memcpy(temp, list, counter-1);
        list = temp;
        free(temp);*/
        ContactInfo *tmp_list = realloc(list, (buff_size + 5) * sizeof(ContactInfo));
        if (tmp_list == NULL)
        {
            free(list);
            printf("Extended Memory Allocation(0) Failed..Quiting..");
            exit(1);
        }
        list = tmp_list;



        /*realloc(clist1, (size +5)*sizeof(ContactInfo*));
        //ContactList temp1 = malloc((size+5)*sizeof(ContactList));
        if(clist1 == NULL){
            printf("Extended Memory Allocation(1) Failed..Quiting..");
            exit(1);
        }
        /*memcpy(temp1, clist1, counter-1);
        clist1 = temp1;*/
        ContactList tmp_list1 = realloc(clist1, (buff_size + 5) * sizeof(ContactInfo *));
        if (tmp_list1 == NULL)
        {
            free(clist1);
            printf("Extended Memory Allocation(1) Failed..Quiting..");
            exit(1);
        }
        clist1 = tmp_list1;


        /*realloc(clist1, (size +5)*sizeof(ContactInfo*));
        //ContactList temp2 = malloc((size+5)*sizeof(ContactList));
        if(clist2 == NULL){
            printf("Extended Memory Allocation(2) Failed..Quiting..");
            exit(1);
        }
        /*memcpy(temp2, clist2, counter-1);
        clist2 = temp2;
        */
        ContactList tmp_list2 = realloc(clist2, (buff_size + 5) * sizeof(ContactInfo *));
        if (tmp_list2 == NULL)
        {
            free(clist2);
            printf("Extended Memory Allocation(2) Failed..Quiting..");
            exit(1);
        }
        clist2 = tmp_list2;

        buff_size = buff_size + 5;  
    }

    list[counter] = ci;
    clist1[counter] = &list[counter];               //holding the location of the list[counter]..
    clist2[counter] = &list[counter];

    counter = counter + 1;              //updating the counter
}



ContactInfo *findByName(ContactList cl, char *name)
{

}

ContactInfo *findByNumber(ContactList cl, int num)
{


}


/*
void deleteContactByName(ContactList cl, ContactList c2, char *name);
void deleteContactByNumber(ContactList cl, ContactList c2, int num);*/

void printContacts(ContactList cl)
{
    int i ;
    for(i=0 ; i<20; i++)
    {
        printf(" %s\n", cl[i]->Name);
    }
}

void Merge(int hi , int lo, ContactList c)
{
    if(hi>lo)
    {
        int mid = (hi + lo)/2;
        Merge(mid, lo, c);
        Merge(mid+1, hi, c);
        Merge_Sort(hi, mid, lo, c);

    }
}

void Merge_Sort(int hi, int mid, int lo, ContactList c)
{
    ContactList arr1 = malloc(((counter/2)+1)*sizeof(ContactInfo *));
    if(arr1 ==  NULL)
    {
        printf("Memory Allocation(3) failed");
    }

    ContactList arr2 = malloc(((counter/2)+1)*sizeof(ContactInfo *));
    if(arr2 ==  NULL)
    {
        printf("Memory Allocation(4) failed");
    }

    int i, j;
    int limit_first = mid - lo + 1 ;
    int limit_second = hi - mid;

    for(i=0; i<limit_first; i++)
    {
        arr1[i] = c[i];
    }

    for(j=0; j<limit_second; i++)
    {
        arr2[j] = c[mid + j + 1];
    }

    /*ContactInfo temp;
    strcpy(temp.Name , "zzzzzzz");
    temp.phon_num = 99999999999;
    strcpy(temp.email_id, "zzzzzzz");

    arr1[i] = &temp;
    arr1[j] = &temp;*/

    int k;
    i=0;
    j=0;
    for(k=0; k<hi; k++)
    {

        if(arr1[i] >= arr2[j])
        {
            c[k] = arr2[j];
            j++;
        }

        else
        {
            c[k] = arr1[i];
            i++;
        }
    }

}

Answer 1

I found the error... i did not need to pass (buff_size+5)*sizeof(contactinfo *) but simply realloc(list, buff_size+5);...worked for me...

Answer 2

I assume ContactList is a typedef to a struct pointer?

When you pass in clist1 to this function it contains a pointer to a block in memory.

realloc possibly changes this pointer to something else (and moves all the memory contents to this new pointer).

This new value is lost when you exit this function as you passed clist1 as a pointer.

To make sure this works correctly, you need to pass a pointer to a pointer and derefence it during the function. This makes sure if the pointer changes, the calling function will know about it.

void addContact(ContactList* clist1, ContactList clist2, ContactInfo ci, int size)
{   

Answer 3

One problem is that realloc() returns the address of the newly allocated memory: store the return value of realloc(). It may allocate a completely new block of memory and copy the content of the memory being realloc'd into and free() the previous memory. Accessing the previous memory, now free()d, is undefined behaviour and is a probable cause of the junk output after reallocation.

Save the return value of realloc() to a temporary pointer and update list (and the other pointers used in conjunction with realloc()) only if non-NULL pointer is returned:

ContactInfo* tmp_list = realloc(list, (buff_size + 5) * sizeof(ContactInfo));
if (tmp_list == NULL)
{
    free(list);
    fprintf(stderr, "Extended Memory Allocation(0) Failed..Quiting..");
    exit(1);
}
list = tmp_list;