Come utilizzare gratuitamente su una maniglia all'interno di una lista -> C -> Windows API

Question

Ho una lista in C che è qualcosa di simile:

typedef struct _node
{
   int number;
   DWORD threadID;
   HANDLE threadH;
   struct *_node next;
} *node;

E avete qualcosa in questo modo:

node new_node = malloc(sizeof(node));

Come avrete intuito fuori, questo elenco sarà memorizzare le informazioni per le discussioni, compresi i loro gestori e ID di. Ancora sto avendo difficoltà quando provo a fare questo:

free(new_node);

Ogni volta che provo a fare questo ho incontrato un errore imprevisto, VS dicendo che c'era una corruzione dei dati. Ho appuntato giù il più possibile, e ho scoperto che risiede il problema quando si tenta di utilizzare gratuitamente la maniglia. Ho cercato su MSDN come fare questo, ma l'unica cosa che riesco a trovare è la funzione che chiude il thread (che non sono destinate qui, perché voglio il filo di correre, basta eliminarlo del record dalla lista).

La domanda è: come dovrei liberare un manico dalla memoria? (Considerando che questa è solo una copia del valore della maniglia, la maniglia attiva non viene cancellato).

EDIT: Questa è la funzione per inserire i nodi dalla lista:

int insereVisitanteLista(node* lista, DWORD threadID, HANDLE threadH, int num_visitante)
{
    node visitanteAnterior;
    node novoVisitante = (node)malloc(sizeof(node));

    if(novoVisitante == NULL)
        return 0;

    novoVisitante->threadID = threadID;
    novoVisitante->threadH = threadH;
    novoVisitante->number = num_visitante;
    novoVisitante->next = NULL;

    if(*lista == NULL)
    {
        *lista = novoVisitante;
        return 1;
    }

    visitanteAnterior = *lista;

    while(visitanteAnterior->next != NULL)
        visitanteAnterior = visitanteAnterior->next;

    visitanteAnterior->next =novoVisitante;
    return 1;
}

E questa è la funzione per i nodi di cancellazione:

int removeVisitanteLista(node * lista, DWORD threadID)
{
    node visitanteAnterior = NULL, visitanteActual;

    if(*lista == NULL)
        return 0;

    visitanteActual = *lista;

    if((*lista)->threadID == threadID)
    {
        *lista = visitanteActual->next;
        visitanteActual->next = NULL;
        free(visitanteActual);

        return 1;
    }

    while(visitanteActual != NULL && visitanteActual->threadID != threadID)
    {
        visitanteAnterior = visitanteActual;
        visitanteActual = visitanteActual->next;
    }

    if (visitanteActual == NULL)
        return 0;

    visitanteAnterior->next = visitanteActual->next;
    free(visitanteActual);

    return 1;
}

Answer 1

Che cosa è esattamente un node che si sta tentando di liberare? È questo un puntatore ad una struct _node? Se sì, avete assegnato in precedenza? Se no, non è necessario free, altrimenti si controlla se il nodo non è NULL e assicurarsi di non free che più volte. E 'difficile indovinare quello che stai facendo e dove si verifica un errore senza un esempio funzionante di dimensioni minimali che riproduce il problema. L'unica cosa che posso suggerire è quello di leggere sulla gestione della memoria in C. Questa risorsa aiuto potenza .

UPDATE:

nodo del codice è un puntatore a _node. Così sizeof (nodo) è una dimensione di un puntatore, che è 4 o 8 byte (a seconda dell'architettura). Quindi si assegnano 8 byte, per esempio, ma supponiamo che avete un puntatore alla struttura, che è molto più grande. Di conseguenza, è danneggiare la memoria, e il comportamento del programma diventa indefinito. Quindi cambiando nodo novoVisitante = (nodo) malloc (sizeof (nodo)) al nodo novoVisitante = (nodo) malloc (sizeof (_node)) dovrebbe risolvere il problema.

Answer 2

Non hai noi mostrato il contesto della chiamata a free () quindi ho bisogno di speculare un po 'ma la mia prima preoccupazione è che lei non ha citato la rimozione del nodo dalla lista prima di eliminarlo.

Avviare scollegando il nodo modificando il campo successivo del (o testa) nodo precedente. Se continui a ricevere l'errore, allora si ha memoria corrotta in qualche modo, scrivendo oltre la fine di uno dei tuoi strutture di memoria allocate o qualcosa di simile.

Inoltre, presumo nodo è un puntatore. Davvero non ha fornito molte informazioni su quello che stai facendo.