Cours : Les Pointeurs en Langage C/C++

La notion du pointeur dans les langages de programmation est incontournable , cette notion permet de résoudre plusieurs problèmes de programmation , cette notion est un peu difficile a comprendre , mais il ne faut pas l'ignoré car elle est très importante dans tous ce qui suivent .

Un Problèmes sans solutions

Considérons un programme contenant a et b deux variables ( des entiers ) , bien sure chaque variable contient une valeur . En veut créer une fonction simple qui permute les valeurs de ces deux variable .

c'est facile alors !! la fonction serait donc :

void permuter( int a , int b ){
    int c;
    c = a;
    a = b;
    b = c;
}

En va voir (:-P) , considérons maintenant le programme suivant :

#include<stdio.h> // #include<iostream>

void permuter( int a , int b ){
    int c;
    c = a;
    a = b;
    b = c;
}

int main(){

    int a=1,b=2;

    permuter(a,b);

    printf("a = %d , b = %d",a,b); // std::cout << "a = " << a << " , b = " << b ;

    return 0;
}

puisqu'on a appelé la fonction permuter , le résultat serait

a = 2 , b = 1

Mais !! si vous exécutez ce programme chez vous vous allez trouver :

a = 1 , b = 2

ici il n y a pas d'erreur , il faut juste bien imaginer comment les fonctions travaillent .
Quece qui c'est passé alors :
les variables a , b dans la fonction permuter() ne sont pas les même dans la fonction main() 

pour comprendre en faire une petite simulation de ce que l'ordinateur fait :

main()

1 - le programme commence toujours par ouvrir la fonction main() , il la réserve un bloc de mémoire .

main()

a 1
b 2

2 - la première ligne dans main() est une déclaration et initialisation des deux entiers a et b , le programme réserve donc l'espace mémoire pour ces deux entiers dans le bloc mémoire de la fonction main() .

permuter()

a ..
b ..

main()

a 1
b 2

3 - dans la ligne suivante , on a l'appelle de la fonction permuter() , l'ordinateur réserve un autre bloc mémoire dont il y a deux variables a et b autres que ceux qui sont dans main() , ces nouvelles variable sont définit dans les arguments de la fonction permuter( int a , int b ) .

permuter()

a 1
b 2

main()

a 1
b 2

et puisque on a fait l'appelle a la fonction permuter() et mettant (a,b) dans les arguments dans cet ordre , le programme va copier la valeur de a , et la mettre dans le premier argument , c-a-d le nouveau a , la même chose pour b .

permuter()

a 2
b 1
c 1

main()

a 1
b 2

4 - dans la fonction permuter() , on a une déclaration d'un entier c pour faire une permutation des valeurs a et b .

main()

a 1
b 2

5 - et comme le programme a terminé les instruction dans la fonction permuter() , il va détruire le bloc mémoire de la fonction en détruisant toutes le variables dedans , et terminer les instructions de la fonction main() .

6 - l'affichage printf() , va se faire pour les anciennes variables a et b .

Conclusion :

• Lorsque le programme fait l'appelle a une fonction , il ne fait pas les opérations sur les variables dans main() mais plutôt il crée des copies sur lesquels il fait ces opérations .
• Ces impossible donc de changer le valeurs de a et b  dans main() a partir d'une autre fonction .

Les Pointeurs

Les pointeurs sont un nouveau genre de variables , qui nous permet de résoudre le problème précèdent , il nous permet d’opérer sur toutes les variables a partir de n'importe quelle fonction . plus précisément les pointeurs nous permet de réaliser directement des changements dans la mémoire .

les pointeurs ont plusieurs types , on dit qu il y a pointeur sur entier , pointeur sur réel , pointeur sur caractère ... .

on les déclares en ajoutant (*) avant le nom :

int * P1 // pointeur sur entier
float * P2 // pointeur sur réel 
char * P3 // pointeur sur caractère 

int * P4, * P5 , * P6 ; // déclaration de plusieurs pointeurs de même type

la mémoire de l'ordinateur est repartie d'une manière bien ordonné , chaque octet a une adresse propre a lui .

les pointeurs prend comme valeurs ces adresses .

int a;  // déclaration d'un entier
int * P;  // déclaration d'un pointeur sur entier

P = &a // P reçoit l'adresse de a 

bien sure le pointeur doit être de même type que la variable .
l’opérateur & donne l'adresse de la variable .
le pointeur P a comme valeur l'adresse de a . on dit que P pointe sur a
pour afficher cette adresse :

printf("l'adresse de a est %p",P);

vous allez trouver quelque chose comme cela

0xbfb276a8

c'est l'adresse de a en Hexadécimale .

maintenant le pointeur P pointe sur a , pour changer la valeur de a a partir du pointeur on ajoute * avant le pointeur .

*P = 5 ;

comme si on dit a notre programme : affect a la variable pointé par P la valeur 5 . c-a-d a = 5 . Alors :

int *P,a; // les déclarations 
P = &a ; // P pointe sur a

*P = 5 // équivalent a dire a = 5

les pointeurs peuvent pointer sur des variables situés dans autres fonctions . il suffit juste de connaitre les adresses .

Revenant au problème 

la solution du problème en utilisant les pointeurs est celle ci :

#include<stdio.h>

void permuter( int * P , int * Q ){ // P pointe sur a , Q pointe sur b
    int c;   
    c = *P;
    *P = *Q;
    *Q = c;
}

int main(){

    int a=1,b=2;

    permuter(&a,&b); // passage par adresse

    printf("a = %d , b = %d",a,b); 

    return 0;
}