pregunta C: eliminar la referencia única en un puntero de indirección doble ** vacío

Question

Tengo este mensaje:

expected 'void **' but argument is of type 'char **' 

cuando traté de compilar algo similar a esto:

void myfree(void **v) 
{ 
    if(!v || !*v) 
     return; 

    free(*v); 
    *v = NULL; 

    return; 
} 

encontré lo que creo que es una solución después de leer esta pregunta en el desbordamiento de la pila:
Avoid incompatible pointer warning when dealing with double-indirection - Stack Overflow

Así ajusté a algo como esto:

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

void myfree(void *x) 
{ 
    void **v = x; 

    if(!v || !*v) 
     return; 

    free(*v); 
    *v = NULL; 

    return; 
} 

int main(int argc, char *argv[]) 
{ 
    char *test; 

    if((test = malloc(1))) 
    { 
     printf("before: %p\n", test); 
     myfree(&test); 
     printf("after: %p\n", test); 
    } 

    return 0; 
} 

¿Es esta C legal? Estoy desreferenciando un puntero de vacío, ¿no?

Gracias chicos


EDITAR 12/10/2010 16:45 EST:
Como se ha señalado free(NULL) es seguro y regulado por la Norma C. Además, como se explica a continuación, mi ejemplo anterior no es legal C. Consulte la respuesta de caf, la respuesta de Zack y mi propia respuesta.

Por lo tanto, va a ser más fácil para mí para inicializar cualquier punteros a-ser-malloc'd como nulo y más tarde a poco libre() y nulos a cabo directamente en el código:

free(pointer); 
pointer = NULL; 

El razón por la que estaba buscando NULL en myfree() como lo hice fue por mis experiencias con fclose(). fclose(NULL) puede segfault dependiendo de la plataforma (por ejemplo, xpsp3 msvcrt.dll 7.0.2600.5512) y entonces asumí (erróneamente) que lo mismo podría pasar con free(). Había pensado en lugar de complicar mi código con sentencias if que podría implementar mejor en una función.

Gracias a todos por la buena discusión

Answer 1

No, esto es no C legal, a menos que pase la dirección de un objeto void *-myfree() (por lo que también podría simplemente mantener su definición original).

La razón es que en su ejemplo, un objeto de tipo char * (el objeto declarado como test en main()) se modifica a través de un lvalue de tipo void * (la lvalue *v en myfree()). §6.5 de los C estados estándar:

7 Un objeto tendrá su valor almacenado accedidos solamente por un expresión lvalue que tiene uno de los siguientes tipos:

— a type compatible with the effective type of the object, 
— a qualified version of a type compatible with the effective type of 
the object, 
— a type that is the signed or unsigned type corresponding to the effective 
type of the object, 
— a type that is the signed or unsigned type corresponding to a qualified 
version of the effective type of the object, 
— an aggregate or union type that includes one of the aforementioned 
types among its members (including, recursively, a member of a subaggregate 
or contained union), or 
— a character type. 

Desde void * y char * no son tipos compatibles, esta restricción se ha roto. La condición para dos tipos de puntero para que sea compatible se describe en §6.7.5.1:

Durante dos tipos de puntero sean compatibles , ambos serán idénticamente cualificado y ambos serán punteros a tipos compatibles.

Para lograr el efecto deseado, debe utilizar una macro:

#define MYFREE(p) (free(p), (p) = NULL) 

(No hay necesidad de comprobar si hay NULL, ya free(NULL) es legal Tenga en cuenta que esta macro evalúa p dos veces.).

Answer 2

Esto es perfectamente legal, pero puede resultar confuso para otras personas que leen el código.

También es posible usar la fundición para eliminar la advertencia:

myfree((void **)&rest); 

Esto es más legible y comprensible.

Answer 3

En C no tiene más remedio que presentar un reparto en algún lugar de aquí. Me gustaría utilizar una macro para asegurar que las cosas se hacen correctamente en el lugar de llamada:

void 
myfree_(void **ptr) 
{ 
    if (!ptr || !*ptr) return; 
    free(*ptr); 
    *ptr = 0; 
} 
#define myfree(ptr) myfree_((void **)&(ptr)) 

[en realidad se podría nombrar tanto la función como la "MyFree" macro, gracias a C de no-infinito-macro-recursividad reglas ! Pero sería confuso para los lectores humanos. Según la larga discusión debajo de la respuesta de café, también estipularé que la declaración *ptr = 0 aquí modifica un objeto de tipo desconocido a través de un alias void**, que es un comportamiento indefinido en el tiempo de ejecución; sin embargo, mi opinión es que no causará problemas en la práctica , y es la opción menos mala disponible en C simple; La macro de café que evalúa su argumento dos veces parece mucho más probable (para mí) causar problemas reales.]

En C++ puede usar una función de plantilla, que es mejor en tres aspectos: evita tener que tomar la dirección de nada en el sitio de la llamada, no se rompe la corrección del tipo, y obtendrá un error de tiempo de compilación en lugar de un bloqueo en tiempo de ejecución si accidentalmente pasa un puntero a myfree.

template <typename T> 
void 
myfree(T*& ptr) 
{ 
    free((void *)ptr); 
    ptr = 0; 
} 

Pero, por supuesto, en C++ tiene incluso mejores opciones disponibles, como el puntero inteligente y clases de contenedor.

Debería mencionarse, finalmente, que los programadores expertos de C evitan este tipo de envoltorio, porque no le ayuda cuando hay otra copia del puntero a la memoria que acaba de liberar colgando en algún lado, y eso es exactamente cuando necesitas ayuda.

Answer 4

caf's la respuesta es correcta: No, no es legal. Y como Zack señala que violar la ley de esta manera aparentemente es menos probable que cause problemas.

Encontré lo que parece ser otra solución en el comp.lang.c FAQ list · Question 4.9, que señala que se debe usar un valor de vacío intermedio.

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

void myfree(void **v) 
{ 
    if(!v) 
     return; 

    free(*v); 
    *v = NULL; 

    return; 
} 

int main(int argc, char *argv[]) 
{ 
    double *num; 

    if((num = malloc(sizeof(double)))) 
    { 
     printf("before: %p\n", num); 

     { 
      void *temp = num; 
      myfree(&temp); 
      num = temp; 
     } 

     printf("after: %p\n", num); 
    } 

    return 0; 
}