Pointeur void en C

Jusqu'à présent, nous avons étudié que l'adresse attribuée au pointeur doit être la même que le type spécifié dans la déclaration du pointeur. Par exemple, si nous déclarons un pointeur int, ce pointeur int ne peut pas pointer vers une variable float ou un autre type de variable, c'est-à-dire qu'il ne peut pointer que vers des variables de type int. Pour surmonter ce problème, nous utilisons un pointeur vers void. Un pointeur vers void est un pointeur générique qui peut pointer vers tout type de données. Nous pouvons attribuer l'adresse de tout type de données à un pointeur void et attribuer un pointeur void à tout type de pointeur, sans effectuer de conversion de type explicite.

Syntaxe du pointeur void

void　*nom du pointeur

Voici la déclaration de pointeur void :

void　*ptr;

Dans la déclaration ci-dessus, void est le type du pointeur et 'ptr' est le nom du pointeur.

Laissez-nous voir quelques exemples :

int i=9;　　　　　　　　　//Initialisation des variables entières
int　*p;　　　　　　　　　//　Déclaration de pointeur d'entier
float　*fp;　　　　　　　　　//　Déclaration de pointeur de flottant
void　*ptr;　　　　　　　　　//Déclaration de pointeur void
p=fp;　　　　　　　　　//　Erreur.
fp=&i;　　　　　　　　　//　Erreur
ptr=p;　　　　　　　　　//　Correct
ptr=fp;　　　　　　　　　//　Correct
ptr=&i;　　　　　　　　　//　Correct

La taille du pointeur void en C

La taille des pointeurs void en C est la même que la taille des pointeurs de type caractère. La représentation des pointeurs vers void est la même que celle des pointeurs de type caractère. La taille des pointeurs dépend de la plateforme utilisée.

Voyons l'exemple suivant :

Exemple

#include <stdio.h>
int main()
{
　　　　void　*ptr = NULL;　//Pointeur void
　　　　int　*p = NULL;//　Pointeur d'entier
　　　　char　*cp = NULL;//Pointeur de caractères
　　　　float　*fp = NULL;//Pointeur flottant
　　　　//La taille du pointeur void
　　　　printf("La taille du pointeur void = %d\n\n",sizeof(ptr));
　　　　//La taille du pointeur d'entier
　　　　printf("La taille du pointeur d'entier = %d\n\n",sizeof(p));
　　　　//La taille du pointeur de caractères
　　　　printf("La taille du pointeur de caractères = %d\n\n",sizeof(cp));
　　　　//La taille du pointeur flottant
　　　　printf("La taille du pointeur flottant = %d\n\n",sizeof(fp));
　　　　return 0;
}

Résultat de la sortie

La taille du pointeur void :　4
La taille du pointeur d'entier :　4
La taille du pointeur de caractères :　4
La taille du pointeur flottant :　4

Les avantages des pointeurs void

Voici les avantages des pointeurs void :

• Les fonctions malloc() et calloc() retournent des pointeurs void, par conséquent, ces fonctions peuvent être utilisées pour allouer de la mémoire pour n'importe quel type de données.

Exemple

#include <stdio.h>
#include<malloc.h>
int main()
{
　　　int a=90;
　
　　　int　*x = (int*)malloc(sizeof(int))　;
　　　x=&a;
　　　printf("La valeur pointée par le pointeur x :　%d",*x);
　　　　return 0;
}

Résultat de la sortie

La valeur pointée par le pointeur x :　90

• Les pointeurs void en C peuvent également être utilisés pour implémenter des fonctions génériques en C.
  

Pourquoi utilisons-nous des pointeurs void ?

En raison de sa réutilisabilité, nous utilisons un pointeur void. Un pointeur void peut stocker n'importe quel type d'objet, et nous pouvons récupérer n'importe quel type d'objet en utilisant un opérateur indirect avec une conversion de type appropriée.

Laissez-nous comprendre à travers un exemple.

Exemple

#include<stdio.h>　
int main()　
{　
　　int a=56;　//Initialiser une variable entière 'a'.
　　float b=4.5;　//Initialisation de la variable flottante 'b'.
　　char c='k';　//Initialisation de la variable de caractères 'c'.
　　　void　*ptr;　//Déclarer un pointeur nul.
　　　//　Allouer une adresse pour la variable "a".
　　　ptr=&a;
　　　printf("La valeur de a est :　%d",*((int*)ptr));
　　　//Allouer une adresse pour la variable 'b'.
　　　ptr=&b;
　　　printf("\nLa valeur de b est :　%f",*((float*)ptr));
　　　//Allocation d'adresse pour la variable 'c'.
　　　ptr=&c;
　　　　printf("\n La valeur de c est : %c",*((char*)ptr));
　　　　return 0;
}

Résultat de la sortie

La valeur de a est :　56
La valeur de b est :　4.500000
　La valeur de c est : k