Modo de empleo libre en un mango dentro de una lista -> C -> Windows API

Question

Tengo una lista en C que es algo como esto:

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

Y usted tiene algo como esto:

node new_node = malloc(sizeof(node));

Como puede haber adivinado a cabo, esta lista almacenar información para las discusiones, incluyendo sus controladores y el ID del. Todavía estoy teniendo problemas al intentar hacer esto:

free(new_node);

Cada vez que intento hacer esto me encuentro con un error inesperado, VS diciendo que había una corrupción de datos. He precisado tanto como sea posible y me encontré con que reside el problema cuando tratan de utilizar libre de la manija. He buscado en MSDN cómo hacer esto, pero lo único que puedo encontrar es la función que cierra el hilo (que no se pretende aquí, ya que quiero que el hilo se ejecuta, simplemente eliminarlo del registro de la lista).

La pregunta es: ¿cómo se supone que debo liberar a un mango de la memoria? (Teniendo en cuenta que esto es sólo una copia del valor de la empuñadura, no se está eliminando el mango activo).

EDIT: Esta es la función para insertar los nodos de la 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;
}

Y esta es la función de borrado de nodos:

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

¿Qué es exactamente un node que usted está tratando de liberar? Es este un puntero a una estructura _node? Si es así, ¿han asignado previamente? Si no, no es necesario free, de lo contrario usted tiene que comprobar si el nodo no es NULL y asegúrese de que no free varias veces. Es difícil de adivinar lo que está haciendo y dónde se produce un error sin un ejemplo de trabajo mínima reproducir el problema. La única cosa que puedo sugerir es leer acerca de la gestión de memoria en C Este recurso ayuda puede .

ACTUALIZACIÓN:

nodo en su código es un puntero a _node. Así sizeof (nodo) es un tamaño de un puntero, que es ya sea de 4 u 8 bytes (dependiendo de la arquitectura). Así se puede asignar 8 bytes, por ejemplo, pero suponga que tiene un puntero a la estructura que es mucho más grande. Como resultado, se corromper la memoria y el comportamiento del programa se convierte en indefinido. Así el cambio de nodo novoVisitante = (nodo) malloc (sizeof (nodo)) al nodo novoVisitante = (nodo) malloc (sizeof (_node)) debe solucionar el problema.

Answer 2

Has no nos muestra el contexto de su llamada a free (), así que necesito a especular un poco, pero mi primera preocupación es que usted no mencionó la eliminación del nodo de la lista antes de eliminarlo.

Start desvinculando el nodo modificando el siguiente campo del nodo anterior (o cabeza). Si sigue apareciendo el error, entonces usted tiene memoria dañada de alguna manera, escribiendo más allá del final de una de sus estructuras de memoria asignados o algo similar.

También nodo, que supongo que es un puntero. Realmente no se ha proporcionado mucha información sobre lo que está haciendo.