Programme d'allocation dynamique de la mémoire (basée sur la structure) s'exécutant différemment sur différents IDE

Question

J'écris un programme pour créer une structure qui est utilisée pour créer une liste, mais je reçois une double erreur gratuite ou de corruption. Je sais que les listes liées seraient une meilleure mise en œuvre, mais je veux savoir ce que je fais mal ici. Le code fonctionne parfaitement dans mon IDE, mais montre l'erreur susmentionnée sur l'exécution en utilisant GCC sur le terminal d'Ubuntu.

/* Implements an employee structure having name and company name 
and can take new employees, delete last employee and display entire list of employees */ 

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

// defining structure employee 
typedef struct emp 
{ 
    char name[20]; 
    char company[20]; 
}emp; 


int p = 0, size = 0; 

void create(emp *); 
void del(emp *); 
void display(emp *); 

int main(void) 
{ 
    emp *buffer = malloc(sizeof(emp)); 
    if (buffer == NULL) 
    { 
     printf("Error"); 
     exit(1); 
    } 
    int n = 0; 
    do 
    { 
     printf("The options are:\n"); 
     printf("1. Add employee\n"); 
     printf("2. Delete employee\n"); 
     printf("3. Display employee\n"); 
     printf("4. Exit\n"); 
     printf("Enter from 1 to 4:"); 
     scanf("%d",&n); 
     if (n == 1) 
     { 
      create(buffer); 
     } 
     else if (n == 2) 
     { 
      del(buffer); 
     } 
     else if (n == 3) 
     { 
      display(buffer); 
     } 
    }while(n != 4); 
    free(buffer); 
    return 0; 
} 

void create(emp *buffer) 
{ 
    size++; 
    if (p != 0) 
    { 
     buffer = realloc(buffer, size * sizeof(emp)); 
     if (buffer == NULL) 
     { 
      printf("Error"); 
      exit(1); 
     } 
    } 
    printf("Enter:"); 
    scanf("%s%s", (buffer + size - 1)->name, (buffer + size - 1)->company); 
    p++; 
} 

void del(emp *buffer) 
{ 
    // deletes only last node 
    size--; 
    buffer = realloc(buffer, size * sizeof(emp)); 
    if (buffer == NULL) 
    { 
     printf("Error"); 
     exit(1); 
    } 
} 

void display(emp *buffer) 
{ 
    int k = 0; 
    for (k = 1; k <= size; k++) 
    { 
     printf("Name:%s\n",(buffer + k - 1)->name); 
     printf("Company:%s\n",(buffer + k - 1)->company); 
    } 
} 

MISE À JOUR: j'ai couru valgrind et je reçois les éléments suivants, mais pas en mesure de comprendre où exactement je réaffecte à tort.

==3322== Invalid free()/delete/delete[]/realloc() 
==3322== at 0x4C2FD5F: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so) 
==3322== by 0x4008C9: create (in /home/akshay/Data/practice/a.out) 
==3322== by 0x40081C: main (in /home/akshay/Data/practice/a.out) 
==3322== Address 0x5203040 is 0 bytes inside a block of size 40 free'd 
==3322== at 0x4C2FD5F: realloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so) 
==3322== by 0x4008C9: create (in /home/akshay/Data/practice/a.out) 
==3322== by 0x40081C: main (in /home/akshay/Data/practice/a.out) 
==3322== Block was alloc'd at 
==3322== at 0x4C2DB8F: malloc (in /usr/lib/valgrind/vgpreload_memcheck-amd64-linux.so) 
==3322== by 0x400786: main (in /home/akshay/Data/practice/a.out) 
==3322== 
Error==3322== 
==3322== HEAP SUMMARY: 
==3322==  in use at exit: 80 bytes in 1 blocks 
==3322== total heap usage: 5 allocs, 4 frees, 2,288 bytes allocated 
==3322== 
==3322== LEAK SUMMARY: 
==3322== definitely lost: 80 bytes in 1 blocks 
==3322== indirectly lost: 0 bytes in 0 blocks 
==3322==  possibly lost: 0 bytes in 0 blocks 
==3322== still reachable: 0 bytes in 0 blocks 
==3322==   suppressed: 0 bytes in 0 blocks 
==3322== Rerun with --leak-check=full to see details of leaked memory 
==3322== 
==3322== For counts of detected and suppressed errors, rerun with: -v 
==3322== ERROR SUMMARY: 1 errors from 1 contexts (suppressed: 0 from 0) 

Answer 1

Vous tampon de passage à create et del en valeur si les modifications que vous apporterez ne sont pas pris en compte. Donc free obtient l'ancienne valeur de buffer. Vous avez 3 options -

O1: rendre le tampon global comme vous l'avez fait pour la taille et ne pas le passer en argument. Facile mais non conseillé. O2: renvoie la nouvelle valeur de buffer de del et create. Puis, pendant l'appel,

buffer = del(buffer); 

O3: Passez un pointeur vers le tampon au lieu du tampon et modifiez-le à l'intérieur. Votre prototype passera à

void create(emp ** buffer); 

Et vous devrez utiliser tous les *buffer où à l'intérieur create (même pour del). également l'appel passera à

create(&buffer); 

C'est un peu compliqué, mais plus une « correcte ».

Un espoir qui vous aide à comprendre le problème.