1. Pointeurs standards

Les pointeurs standards sont les plus courants, comme les pointeurs de type int * ou char *. Même le nom d'un tableau, tel que arr[5], peut être considéré comme un pointeur, car un pointeur est essentiellement une adresse, et arr représente l'adresse du premier élément du tableau. Cependant, il est important de noter que sizeof(arr) et &arr représentent l'adresse de l'ensemble du tableau. Bien que la valeur de l'adresse soit la même, les opérations d'incrémentation ou de décrémentation diffèrent : incrémenter un pointeur standard avance d'un élément, tandis qu'incrémenter l'adresse du tableau entier saute la taille totale du tableau.

2. Pointeurs sauvages

Un pointeur sauvage (wild pointer) est un pointeur qui pointe vers une position inconnue ou incorrecte. Cela peut se produire dans plusieurs scénarios :

Initialisation manquante :

#include <stdio.h>
int main()
{
    int *ptr; // Pointeur non initialisé, valeur aléatoire
    *ptr = 50;
    return 0;
}

Accès hors limites :

#include <stdio.h>
int main()
{
    int tableau[10] = {0};
    int *pointeur = &tableau[0];
    int compteur = 0;
    for (compteur = 0; compteur <= 12; compteur++)
    {
        // Lorsque le pointeur dépasse la portée du tableau, il devient sauvage
        *(pointeur++) = compteur;
    }
    return 0;
}

Libération d'espace mémoire :

#include <stdio.h>
int* obtenirNombre()
{
    int valeur = 200;
    return &valeur;
}
int main()
{
    int *ref = obtenirNombre();
    printf("%d\n", *ref);
    return 0;
}

À la sortie de la fonction, la mémoire attribuée à la variable locale est libérée, rendant l'adresse stockée dans le pointeur invalide.

3. Pointeurs génériques (type void *)

Les pointeurs de type void * peuvent stocker l'adresse de n'importe quel type de données, ce qui les rend utiles pour une programmation générique. Toutefois, ils ne permettent pas d'effectuer directement des opérations arithmétiques sur les pointeurs. Ces pointeurs sont souvent utilisés dans les paramètres de fonctions pour gérer différents types de données.

#include <stdio.h>
int main()
{
    int nombre = 15;
    void *ptG = &nombre;
    void *ptH = &nombre;
    // Les opérations directes sur void* sont invalides
    return 0;
}

4. Pointeurs de second niveau

Un pointeur de second niveau stocke l'adresse d'un pointeur de premier niveau. En essence, c'est toujours une adresse. La quantité de mémoire incrémentée (4 ou 8 octets) dépend de l'architecture du système (32 bits ou 64 bits).

5. Pointeurs de tableau

Un pointeur de tableau est une variable pointeur qui pointe vers un tableau complet. Sa déclaration suit le format type (*nom)[taille]. Par exemple, pour initialiser un pointeur de tableau : int (*ptTab)[10] = &tableau;.

6. Pointeurs de fonction

Un pointeur de fonction stocke l'adresse d'une fonction. Le nom d'une fonction représente son adresse, ou on peut utiliser &nomFonction pour l'obtenir.

7. Pointeurs de structure

#include <stdio.h>
struct Donnees {
    int identifiant;
    char *nom;
    float valeur;
} *ptStruct = (struct Donnees*)0x200000;

Ici, ptStruct est un pointeur vers une structure. Incrémenter ce pointeur (ptStruct++) avance de la taille totale de la structure.

8. Pointeurs de fichier

Un pointeur de fichier (FILE *pf;) est une variable qui pointe vers une structure FILE, laquelle contient des informations sur un fichier ouvert (nom, état, position courante, etc.). Chaque fichier utilisé génère automatiquement une instance de cette structure en mémoire.

9. Tableaux de pointeurs (non des pointeurs)

Un tableau de pointeurs est un tableau dont chaque élément est un pointeur. À ne pas confondre avec un pointeur de tableau. Par exemple :

int *tabPointeurs[5]; // Tableau de 5 pointeurs int
int (*pointeurTab)[5]; // Pointeur vers un tableau de 5 entiers

Dans tabPointeurs[5], tabPointeurs est un tableau de pointeurs. Dans (*pointeurTab)[5], pointeurTab est un pointeur de tableau.