freien Speicher der Struktur, die ein Array von anderen Struktur innerhalb hat - C

Question

Ich versuche, ein dynamisches Array zu verwenden, wenn ich es zu verwenden, versuche ich, den Speicher freizugeben, und ich bekomme diesen Fehler.

free(): invalid next size (fast): 0x00652098 

Dies sind die Erklärungen der Struktur Variablen:

struct player { 
int played_time; 
int min_time; 
int max_time; 
int errors; 
int color; 
}; 

struct Players { 
struct player *array; 
size_t player_number; 
size_t size; 
}; 
typedef struct Players Player_list; 

Dies sind die Verfahren verwendet, um das dynamische Array zu verwalten:

void initArray(Player_list *list, size_t initialSize) { 
    list->array = (struct player *) malloc(initialSize * sizeof(struct player)); 
    list->player_number = 0; 
    list->size = initialSize; 
} 

void insertArray(Player_list *list, struct player element) { 
    if (list->player_number == list->size) { 
    list->size *= 2; 
    list->array = (struct player *) realloc(list->array, 
      list->size * sizeof(struct player)); 
    } 
    list->array[list->player_number++] = element; 
} 

void freeArray(Player_list *list) { 
    free(list->array); 
    list->array = NULL; 
    list->player_number = list->size = 0; 
} 

int disqualified(Player_list *list, int errors) { 
    int i = 0; 
    for (i = 0; i < list->player_number; i++) { 
    if (list->array[i].errors >= errors) { 
     return 1; 
    } 
    } 
    return 0; 
    } 

Und hier ist, wie ich es in der Verwendung Haupt:

/** 
* When button is pressed 1 add an error to a random player 
*/ 
void button_s_isr(void) { 
    int index = rand() % (players.player_number); 
    point_players->array[index].errors = point_players->array[index].errors  + 1; 

} 

     ... 

int main(void) { 

     ... 
// set up of GPIO 
// get with scanf NUMBER_OF_PLAYERS and MAX_ERRORS values 

int i; 
for (i = 0; i < NUMBER_OF_PLAYERS; i++) { 
    struct player player; 
    player.color = PLAYER_COLORS[i]; 
    player.errors = 0; 
    player.max_time = 0; 
    player.min_time = 0; 
    player.played_time = 0; 
    insertArray(&players, player); 
} 

while (disqualified(&players, MAX_ERRORS) != 1) { 
// wait 
} 
printf("\n Se ha acabdo el juego: "); 
freeArray(point_players); 
return EXIT_SUCCESS; 
} 

Ich muss sagen, ich bin ziemlich neu in C, tut mir leid, wenn es schwer zu verstehen ist. Was ich tun möchte, ist eine dynamische Liste der Struktur (Spieler), wo jeder Spieler eigene Parameter (played_time, min_time, max_time, Fehler, Farbe) hat. Und innerhalb des Main möchte ich ein Spiel haben, wo ich diese Parameter von jedem Spieler kontrollieren kann. Jede Hilfe zur Verbesserung des Codes wird geschätzt.

Answer 1

der entsandte Code:

1. nicht kompiliert
2. wird Definitionen für PLAYER_COLORS fehlen [i], das eine schlechte Idee ist, wie die Anzahl von Spielern zu nutzen, um die verfügbaren Farben in dem Array nicht überschreiten.
3. berechnet falsch die Größe für die
4. realloc() benötigt nicht die zurückgegebenen Werte von Funktionen wie malloc() und realloc()
5. enthält eine verwirrende (auch für die OP) Benennung von Variablen und struct Instanzen
6. fehlt zu überprüfen, ist die Definition für num_jugadores
7. versucht falsch eine Struktur eher zuweisen als die Struktur Kopieren
8. eine Instanz von struct Players
zu erklären, schlägt fehl

und nun korrigiert Code, der kompiliert sauber:

Einschränkung: nicht vollständig getestet

#include <stdio.h> 
#include <stdlib.h> 
#include <string.h> // memcpy() 

struct player 
{ 
    int played_time; 
    int min_time; 
    int max_time; 
    int errors; 
    int color; 
}; 

struct Players 
{ 
    struct player *array; 
    size_t player_number; 
    size_t numPlayers; 
}; 


//This are the method used to manage the dynamic array: 

void freeArray(struct Players *pArray) 
{ 
    free(pArray->array); 
    pArray->array = NULL; 
    pArray->player_number = pArray->numPlayers = 0; 
} 


void initArray(struct Players *pArray) 
{ 
    if(NULL == (pArray->array = malloc(sizeof(struct player)))) 
    { // then malloc failed 
     freeArray(pArray); 
     exit(EXIT_FAILURE); 
    } 

    // implied else, malloc successful 

    pArray->player_number = 0; 
    pArray->numPlayers = 1; 
} 


size_t sizeof_array(size_t size) 
{ 
    return size * sizeof(struct player); 
} 


void insertArray(struct Players *pArray, struct player *element) 
{ 
    if (pArray->player_number == pArray->numPlayers) 
    { // then currently allocated memory for array of players is full 

     struct player *temp = NULL; 
     if(NULL == (temp = realloc(pArray->array, sizeof_array(pArray->numPlayers)*2))) 
     { // then, realloc failed 
      freeArray(pArray); 
      exit(EXIT_FAILURE); 
     } 

     // implied else, realloc successful 

     pArray->numPlayers *= 2; 
     pArray->array = temp; 
    } 

    memcpy(&(pArray->array[pArray->player_number]), element, sizeof(struct player)); 
    pArray->player_number++; 
} 

//and here is how i use it in the main method: 

#define num_jugadores (20) 

int main(void) 
{ 
    int i; 
    struct Players playerList; 

    initArray(&playerList); 

    for (i = 0; i < num_jugadores; i++) 
    { 
     struct player myPlayer; 
     //player.color = PLAYER_COLORS[i]; 
     myPlayer.errors = 0; 
     myPlayer.max_time = 0; 
     myPlayer.min_time = 0; 
     myPlayer.played_time = 0; 
     insertArray(&playerList, &myPlayer); 
    } 


    //... 

    freeArray(&playerList); 
} // end function: main 

Answer 2

Ein solcher Fehler tritt normalerweise auf, weil Sie über das Ende des deklarierten Speichers hinaus schreiben. Während wir den Fehler wahrscheinlich finden könnten, indem wir sorgfältig jede Codezeile übergingen, würde Valgrind es für Sie viel schneller finden.

Versuchen Sie, Ihren Code im Debug-Modus ohne Optimierungen zu kompilieren (gcc -g -O0, wenn Sie gcc verwenden) und führen Sie Ihr Programm unter valgrind (z. B. valgrind myprog-my-prog-options). Es sollte den Fehler sofort melden.

All dies setzt voraus, dass Sie eine Variante von Linux ausführen. Wenn Sie Visual Studio verwenden, wird es wahrscheinlich eine ähnliche Speicherprüfung geben, aber ich weiß nicht, was es ist oder wie es ausgeführt wird. Viel Glück!