Références

Les références sont un concept fondamental en informatique. Elles permettent de manipuler des données de manière indirecte, de partager des données entre différentes parties d’un programme, et de construire des structures de données complexes. Comprendre les références est essentiel pour tout programmeur, car elles sont omniprésentes les langages de programmation modernes.

L’abstraction fondamentale

Un pointeur est une référence vers une donnée. Il permet d’accéder à une valeur située ailleurs en mémoire. L’idée essentielle est que une variable peut contenir soit une valeur, soit un moyen d’accéder à une autre valeur.

Par exemple x = 42 signifie que la variable x contient la valeur 42, tandis que p → x signifie que la variable p contient une référence (adresse) vers la variable x.

• Un pointeur est une référence vers une donnée

• Un pointeur contient directement la valeur de la variable qu’il désigne

• La notation p → x signifie que p contient l” de la variable x

Le modèle des boîtes et des flèches

On peut représenter la mémoire par des boîtes et les références par des flèches.

• Dans ce modèle, les références sont représentées par des flèches

• Dans ce modèle, les cases mémoire contenant des valeurs sont représentées par des

L’opération fondamentale

Un pointeur permet deux opérations :

• la lecture c’est à dire accéder à la valeur pointée, souvent exprimée de façon abstraite par obtenir(p) ;

• l’écriture c’est à dire modifier la valeur pointée, souvent exprimée de façon abstraite par modifier(p, nouvelle_valeur).

Un graphe d’objets

Une vision moderne consiste à voir la mémoire comme un graphe.

        graph TD
   A((A))
   B((B))
   C((C))
   A --> B
   A --> C
    

Les pointeurs sont alors simplement des arêtes du graphe.

Cette abstraction permet de décrire des structures de données complexes comme :

• listes chaînées ;

• arbres ;

• graphes ;

• objets ;

• références Python ;

• pointeurs C.

• Dans la vision graphe, les pointeurs représentent des arêtes

• Les références Python peuvent être représentées comme des arêtes dans un graphe

• Parmi les structures de données citées, les listes sont un exemple de structure décrite par un graphe d’objets

• Les arbres peuvent également être représentés comme des graphes d’objets

L’abstraction « Référence »

Sans jamais parler d’adresse mémoire, on peut définir une abstraction de la notion de référence comme suit :

• créer(objet) : crée une référence vers l’objet donné ;

• obtenir(ref) : retourne l’objet référencé par la référence donnée ;

• modifier(ref, objet) : modifie l’objet référencé par la référence donnée.

Cette abstraction fonctionne pour C (pointeurs) et pour Python (références d’objets).

• L’abstraction référence fonctionne à la fois pour les pointeurs C et les références Python

• L’abstraction référence nécessite de manipuler des adresses mémoire explicitement

• Les 3 opérations de l’abstraction référence sont créer, obtenir et

Les pointeurs C

Le rôle majeur des pointeurs est de permettre le partage de données. Ils permettent à plusieurs variables de faire référence à la même donnée, ce qui est essentiel pour construire des structures de données complexes et pour optimiser l’utilisation de la mémoire. Sans référence, A possède une copie et B possède une copie seraient les seules options, ce qui rendrait impossible le partage de données.

Avec les références, on peut dire que A et B font référence à la même donnée, ce qui permet de construire des structures de données plus complexes et de partager des données entre différentes parties d’un programme.

Un des fondements du langage C est la manipulation directe de la mémoire. C’est une vraie particularité du C, car tous les langages de haut niveau comme Java ou Python mettent en oeuvre des mécanismes automatiques de réservation, protection et libération de la mémoire utilisée.

La manipulation de la mémoire va nécessiter d’accéder à l’adresse des variables. On se servira pour cela d’un pointeur, une variable particulière qui ne contient pas de valeur mais l’adresse mémoire d’une autre variable.

L’utilisation des pointeurs est incontournable, elle facilite la programmation dans certains cas, voire est indispensable dans d’autres.

• En C, la gestion de la mémoire est automatique comme en Java ou Python

• Les pointeurs permettent à plusieurs variables de partager la même donnée

• Un pointeur C est une variable qui contient l” d’une autre variable

• L’utilisation des pointeurs est incontournable en C

Le principe

L’idée générale est de ne plus manipuler seulement les valeurs des variables, mais également leur adresse mémoire. On considère le code source suivant, dans lequel deux variables sont déclarées en mémoire :

// pointers.c

#include <stdio.h>

int main()
{
    int b = 4;
    int* a = &b;
    return 0;
}

Dans ce programme :

• b est une variable de type int (entier) dont la valeur est initialisée à 4 ;

• a est une variable de type int* (pointeur vers un entier) et dont la valeur est initialisée à l’adresse de b.

La variable a contient une valeur particulière qui n’est ni un int, ni un double, ni un char. Il s’agit de l’adresse d’une autre variable.

Modifions un peu le code pour afficher les valeurs et les adresses de chacune des deux variables a et b :

// pointers.c

#include <stdio.h>

int main()
{
    int b = 4;
    int* a = &b;

    printf("b  = %d\n", b);   // valeur de b
    printf("&b = %p\n", &b);  // adresse de b
    printf("a  = %p\n", a);   // valeur de a
    printf("*a = %d\n", *a);  // valeur pointée par a
    printf("&a = %p\n", &a);  // adresse de a

    return 0;
}

Observer attentivement ce code, et en particulier

• l’emplacement réservé %p utilisé pour afficher un pointeur (l’adresse d’une variable) (ligne 11) ;

• l’opérateur & permettant d’accéder à l’adresse d’une variable (ligne 11) ;

• l’opérateur d’indirection * utilisé pour accéder au contenu d’un pointeur (ligne 13).

Note

• l’opérateur & s’applique à toute variable ;

• l’opérateur d’indirection * n’est valide que si la variable à laquelle il s’applique est un pointeur ;

• lorsqu’ils sont chainés, les opérateurs & et * s’évaluent de droite à gauche.

Ce code produit l’affichage suivant (les adresses mémoires seront différentes sur votre machine)

b  = 4
&b = 0x7ffd1191ca00
a  = 0x7ffd1191ca00
*a = 4
&a = 0x7ffd1191c7ac

ce qui correspond à la figure ci dessous.

En résumé :

• b est une variable de type int (entier) située à l’adresse 0x7ffd1191ca00 et dont la valeur est 4 ;

• a est une variable de type int* (pointeur vers un entier) située à l’adresse 0x7ffd1191c7ac et dont la valeur est 0x7ffd1191ca00 (l’adresse de b). Le contenu de la variable pointée par a est 4.

Dans ce qui suit, b est un int et a un pointeur vers b.

Dans ce qui suit, b est un int et a un pointeur vers b.

• 01 - L’opérateur d’indirection, utilisé pour récupérer la valeur d’une variable dont on connait le pointeur est

• 02 - L’opérateur permettant d’obtenir l’adresse d’une variable est

• 03 - l’expression &a est valide

• 04 - l’expression &b est valide

• 05 - l’expression *a est valide

• 06 - l’expression *b est valide

• 07 - l’expression &*a est valide

• 08 - l’expression &*a fournit l’adresse de a

• 09 - l’expression &*a fournit l’adresse de b

• 10 - l’expression &*a fournit la valeur de a

• 11 - l’expression &*a fournit la valeur de b

• 12 - l’expression &*b est valide

• 13 - l’expression &*b fournit l’adresse de a

• 14 - l’expression &*b fournit l’adresse de b

• 15 - l’expression &*b fournit la valeur de a

• 16 - l’expression &*b fournit la valeur de b

• 17 - l’expression *&a est valide

• 18 - l’expression *&a fournit l’adresse de a

• 19 - l’expression *&a fournit l’adresse de b

• 20 - l’expression *&a fournit la valeur de a

• 21 - l’expression *&a fournit la valeur de b

• 22 - l’expression *&b est valide

• 23 - l’expression *&b fournit l’adresse de a

• 24 - l’expression *&b fournit l’adresse de b

• 25 - l’expression *&b fournit la valeur de a

• 26 - l’expression *&b fournit la valeur de b

La déclaration

Un pointeur est une variable dont la valeur est l’adresse mémoire d’une autre variable. Comme toute variable dans un programme C elle doit être déclarée avant utilisation.

Pour illustrer ça, commentons la ligne 7 du code ci dessus, ce qui a pour effet de ne pas déclarer la variable b. Le compilateur produit un message du type:

pointers.c: In function 'main':
pointers.c:7:15: error: 'b' undeclared (first use in this function)
    7 |     int* a = &b;
    |               ^
pointers.c:7:15: note: each undeclared identifier is reported only once for each function it appears in

Analyser toutes les informations fournies par ce message d’erreur.

• L’erreur de compilation concerne le fichier

• L’erreur de compilation concerne la fonction

• L’erreur de compilation se situe à la ligne

• On peut localiser la position de l’erreur de compilation sur la ligne

• L’erreur de compilation est due à l’absence d’initialisation

• L’erreur de compilation est due à l’absence de déclaration

La forme générale de déclaration des pointeurs est la suivante:

type *varname;

L’astéristique identifie varname comme un pointeur vers une variable de type type. Pour les types courants :

int    *i;    /* pointeur vers un int */
double *d;    /* pointeur vers un double */
char   *c     /* pointeur vers un character */

Note

Il y a deux écritures possibles pour la déclaration d’un pointeur. Les deux sont valides, équivalentes et expriment deux façons de voir les choses. Selon le cas, il sera plus signifiant de considérer l’une ou l’autre :

• int *i; exprime le fait que le contenu de i est un int ;

• int* i; exprime le fait que i est un pointeur vers un int.

• Dans la déclaration int *i, le symbole * indique que i est un

• int *i et int* i sont deux déclarations équivalentes en C

• Le type C pour un pointeur vers un double s’écrit

Les références en Python

En Python, les variables sont toujours des références à des objets. Par exemple :

a = [1, 2, 3]        # 1. la liste [1, 2, 3] est créée en mémoire, 2. la variable a fait référence à cette liste
b = a                # la variable b fait référence à la même liste que a

Ici, a et b font référence au même objet liste. Si on modifie la liste à travers a, la modification est visible à travers b :

>>> a = [1, 2, 3]
>>> b = a
>>> id(a) == id(b)
True
>>> a.append(4)
>>> print(b)
[1, 2, 3, 4]

Si on veut créer deux structures de données indépendantes, il faut explicitement copier l’objet, ce qui crée deux références vers deux objets distincts. Il y a création d’un nouvel objet, et la variable b fait référence à ce nouvel objet. Par exemple :

>>> a = [1, 2, 3]
>>> b = a.copy()
>>> id(a) == id(b)
False
>>> a.append(4)
>>> print(b)
[1, 2, 3]

Important

En Python le programmeur n’a accès qu’à l’espace des références. En C, le programmeur a accès à l’espace des références (pointeurs) et à l’espace des objets, ce qui crée une complexité supplémentaire, mais permet de manipuler la mémoire de manière plus fine.

Note

Il existe du sucre syntaxique pour les références en Python. Ainsi b = list(a) réalise la même opération que a.copy().

Note

La méthode copy() crée une copie superficielle de la liste. Si la liste contient des objets mutables, les références à ces objets sont copiées, pas les objets eux-mêmes. Pour créer une copie indépendante de tous les objets imbriqués, il faut utiliser copy.deepcopy().

Note

Une référence Python a un comportement très proche d’un pointeur C (copie de l’adresse lors de l’affectation, partage du même objet), mais elle ne permet pas l’arithmétique des pointeurs, ne peut pas être déréférencée explicitement (*), et sa gestion mémoire est assurée automatiquement par l’interpréteur (comptage de références et ramasse-miettes).

• En Python, b = a crée une copie de l’objet référencé par a

• Après b = a, l’expression id(a) == id(b) est vraie

• Pour créer une copie indépendante d’une liste, on utilise la méthode

• La méthode copy() crée une copie profonde de tous les objets imbriqués

• Pour une copie profonde, on utilise

• Une référence Python permet l’arithmétique des pointeurs comme en C