punteros void: diferencia entre C y C++

Question

Estoy tratando de entender las diferencias entre C y C++ con respecto a punteros void. las siguientes compila en C, pero no C++ (todas las compilaciones de hecho con gcc/g ++ -ansi -pedantic -Wall):

int* p = malloc(sizeof(int)); 

porque malloc rendimientos void*, que C++ no permite asignar a int* mientras que C no permite ese.

Sin embargo, aquí:

void foo(void* vptr) 
{ 
} 

int main() 
{ 
    int* p = (int*) malloc(sizeof(int)); 
    foo(p); 
    return 0; 
} 

Tanto C++ y C compilarlo con ninguna queja. ¿Por qué?

K & R2 decir:

Cualquier puntero a un objeto puede ser convertir al tipo void * sin pérdida de información. Si el resultado es convierte de nuevo a la original tipo de puntero, el puntero original es recuperado.

Y esta bonita suma todo lo que hay acerca de void* conversiones en C. ¿Qué es lo que dicta el estándar C++?

Answer 1

En C, las conversiones puntero hacia y desde void* eran siempre implícita.

En C++, las conversiones de T* a void* son implícitas, pero void* a cualquier otra cosa requiere un lanzamiento.

Answer 2

C++ es más-fuertemente tipado de C. Muchas conversiones, especialmente aquellas que implican una interpretación diferente del valor, requiere una conversión explícita. El operador new en C++ es una forma segura de tipo para asignar memoria en el montón, sin un molde explícito.

Answer 3

Es útil entender que las conversiones de tipos de puntero en realidad no requieren la ejecución de instrucciones de CPU adicionales. Se analizan durante el tiempo de compilación para comprender las intenciones del desarrollador. void * es un puntero opaco. Todo dice que el tipo de objeto puntiagudo es desconocido. C está débilmente tipado. Permite la conversión directa entre (void *) y cualquiera (T*) implícitamente. C++ está fuertemente tipado. Una conversión de (void *) a (T*) no sería un buen argumento para un lenguaje fuertemente tipado. Pero C++ tenía que permanecer compatible con C, por lo tanto, tenía que permitir tales conversiones. El principio rector es: lo explícito es mejor que lo implícito. Por lo tanto, si desea convertir un (void*) a algún puntero específico (T*), debe escribirlo explícitamente en el código. La conversión de (T*) a (void*) no requiere conversión explícita, ya no hay nada mucho que se puede hacer en un (void *) puntero directamente (se puede llamar libre de() sin embargo). Por lo tanto, (T*) a (void*) la conversión es bastante segura.