Comprendre les pointeurs vides : différences entre C et C

Les pointeurs vides sont un aspect clé de C et C, mais il existe des différences notables dans leur manipulation. Cet article explore ces différences et explique pourquoi des comportements apparemment contradictoires peuvent se produire.

Conversions implicites en C

En C, les conversions entre un pointeur vers un type spécifique (par exemple, int) et un pointeur void (void) sont toujours implicites. Cela signifie que l'instruction suivante est valide :

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

La fonction malloc renvoie un void*, qui est ensuite attribué au pointeur int*. Cependant, en C , de telles conversions implicites ne sont pas autorisées.

Casting explicite en C

En C , la conversion d'un pointeur en pointeur vide est toujours implicite, mais la conversion d'un pointeur vide en un type spécifique nécessite une conversion explicite. Cela explique pourquoi le code suivant est compilé en C et en C :

void foo(void* vptr)
{
}

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

La fonction malloc renvoie un void*, qui est passé à la fonction foo. Même si le pointeur int* est affecté au paramètre void*, C autorise cette conversion implicite. Cependant, l'appel ultérieur à p nécessite une conversion explicite vers le type int*.

La perspective de la norme

Selon la spécification K&R2, tout pointeur vers un objet peut être converti en toute sécurité en void* sans perte d'informations. De plus, la reconversion au type de pointeur d'origine restaure la valeur d'origine. En C , la norme spécifie que les conversions implicites de n'importe quel type de pointeur vers void* sont autorisées, mais un casting explicite est nécessaire pour les conversions de void* vers tout autre type.

Conclusion

La principale différence entre la gestion des pointeurs vides C et C réside dans l'exigence d'un casting explicite lors de la conversion de void* en un type spécifique en C . Cette approche plus stricte permet d'éviter les comportements indéfinis et de maintenir la sécurité des types dans le code C.