lenguaje - punteros vacíos: diferencia entre C y C++

punteros c++

Question

Estoy tratando de entender las diferencias entre C y C ++ con respecto a los punteros de vacío. las siguientes compilaciones en C pero no en C ++ (todas las compilaciones realizadas con gcc / g ++ -ansi -pedantic -Wall):

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

Como malloc devuelve void* , que C ++ no permite asignar a int* mientras que C sí lo permite.

Sin embargo, aquí:

void foo(void* vptr)
{
}

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

Tanto C ++ como C lo compilan sin quejarse. ¿Por qué?

K & R2 dicen:

Cualquier puntero a un objeto puede convertirse al tipo void * sin pérdida de información. Si el resultado se convierte de nuevo al tipo de puntero original, se recupera el puntero original.

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

Answer 1

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

Answer 2

En C, las conversiones de puntero a y desde void* siempre fueron implícitas.

En C ++, las conversiones de T* a void* son implícitas, pero void* a cualquier otra cosa requiere una conversión.

Answer 3

Es útil comprender que las conversiones de tipo puntero no requieren realmente 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 lo que dice es que el tipo de objeto puntiagudo es desconocido. C se escribe débilmente Permite la conversión directa entre ( void * ) y cualquier ( T* ) implícitamente. C ++ está fuertemente tipado. Una conversión de ( void * ) a ( T* ) realmente no sería un buen caso para un lenguaje fuertemente tipado. Pero C ++ tenía que mantenerse compatible con C, por lo que tenía que permitir tales conversiones. El principio rector entonces es: explícito es mejor que 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 una conversión explícita, ya que no hay nada que uno pueda hacer directamente en un puntero (void *) (aunque se puede llamar free ()). Por lo tanto, la conversión de ( T* ) a ( void* ) es bastante segura.