Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

Déclarateur de pointeur (*) en C++

Découvrez comment `*` déclare un pointeur en ISO C++23, à quel type s’applique `const` et comment distinguer un pointeur de tableau d’un tableau de pointeurs.

Version : ISO C++23; implementation support may vary

Syntaxe

T* p = nullptr;
T const* read = &obj;
T* const fixed = &obj;
T const* const fixed_read = &obj;
T** pp = &p;
T* slots[N];
T (*whole)[N] = &array;
R (*fn)(Args...);

Dans int* p, q;, l’astérisque appartient uniquement au déclarateur de p : q est de type int. Les espaces n’y changent rien. Chaque astérisque ajoute un niveau d’indirection : int** pp est un pointeur vers un pointeur. Dans les expressions, l’opérateur intégré & dans &x prend l’adresse de x, et l’opérateur unaire intégré * dans *p déréférence le pointeur : il ne s’agit ni d’une déclaration ni d’une multiplication. Dans int& r = x;, & déclare une référence lvalue et ne prend pas d’adresse.

const int* p (ou int const* p) permet de réaffecter p, mais pas de modifier l’int pointé via p. Avec int* const p, la valeur du pointeur ne peut pas changer après l’initialisation, mais l’int pointé reste modifiable. const int* const p cumule les deux restrictions. Pour des paramètres passés par valeur, int* et const int* permettent de distinguer des surcharges ; int* et int* const ne le permettent pas.

int* a[3] est un tableau de trois pointeurs ; int (*a)[3] est un pointeur vers un tableau entier de trois int. De même, int (*f)(double) est un pointeur vers une fonction, tandis que int* f(double) déclare une fonction qui renvoie un pointeur. int C::* m déclare un type distinct : un pointeur vers un membre de données non statique de C.

Un pointeur brut n’exprime pas à lui seul la propriété de l’objet et ne prolonge pas sa durée de vie. Un tableau peut être converti en pointeur vers son premier élément ; ce pointeur ne contient pas la longueur. Si un pointeur ne doit encore désigner aucun objet, initialisez-le à nullptr plutôt que de laisser un pointeur local non initialisé. Un test vérifiant que le pointeur est différent de nullptr ne garantit ni que l’objet est encore en vie ni que l’indice est dans les limites. Déréférencer un pointeur nul ou placé juste après la fin du tableau, ou accéder à un objet via un pointeur pendant, entraîne un comportement indéfini.

Exemples

#include <iostream>

int main() {
    int values[3]{2, 4, 6};
    const int* read = values;
    int* const first = &values[0];
    int (*whole)[3] = &values;

    *first = 3;
    std::cout << *read << ' ' << (*whole)[2] << '\n';
}

Résultat

3 6

`read` pointe vers le premier élément sans permettre de le modifier. `first` pointe vers le même élément, ne peut pas être réaffecté et permet d’y écrire `3` via `*first`. `whole` pointe vers le tableau entier ; `(*whole)[2]` lit donc son troisième élément. Sortie attendue : `3 6`.

Leçons associées

  • C++ · Leçon 47 · Avancé · Version : 3
  • C++ · Leçon 49 · Avancé · Version : 3
  • C++ · Leçon 51 · Avancé · Version : 3
  • C++ · Leçon 56 · Avancé · Version : 3
  • C++ · Leçon 58 · Avancé · Version : 3

Sources