Pointeur C ++ vers pointeur const

Ce que vous recherchez est int const * const * ppTarget . Non, attendez, vous recherchez int const ** const ppTarget . Non non, c'est int * const * const * ppTarget .

Il y a de fortes chances que l'un d'entre eux soit correct (je parie le premier). Cependant, vous ne voulez pas que les gens lisant votre code devinent ce que vous voulez dire. C'est trop déroutant. C ++ peut vous le faire.

Ce que vous devez faire, c'est utiliser des typedef s pour vous assurer que les personnes qui lisent le code comprennent ce que vous voulez.

typedef const int *CINT_PTR;
CINT_PTR pTarget = ....;
CINT_PTR *ppTarget = &pTarget;

Je lis toujours les définitions C / C ++ du nom de variable le plus à droite vers la gauche.

Donc:

• const char * p;

  p est un pointeur vers un char qui est const

  Ainsi, p peut être modifié, mais * p ne le peut pas.

• const char * * const p = & a;

  p est un pointeur const vers un pointeur vers un char qui est const .

  Donc p ne peut pas être modifié (donc je l'ai initialisé); * p peut; mais ** p ne peut pas.

[EDIT - tableaux ajoutés par souci d'exhaustivité]

• const char * * const p [4] = {& a, & b, & c, & d};

  p est un tableau de 4 éléments de pointeurs const vers ...

Je veux donc que pTargets pointe vers la mémoire constante et soit const lui-même, ce serait int const * const pTargets = / * assigné une fois * / . Ensuite je veulent déclarer ppTargets que ppTargets lui-même peut être attribué, mais alors * ppTargets ne peut être lu.

Malheureusement, cela n'a aucun sens. Votre exemple de code est affecté à * ppTargets , comme cela semble être l'objectif principal de la fonction foo () . Si * ppTargets peut être attribué une fois, il peut être attribué à nouveau.

On ne sait pas pourquoi vous voulez le foo () > pTargets pour être const , au lieu de simplement ne pas le modifier, mais vous pouvez attribuer une valeur const à un objet du non- correspondant const - type qualifié. Ainsi, ce que vous recherchez peut être

int const* pTargets;
foo(&pTargets);

Et cela semble être cohérent avec votre utilisation prévue:

En d'autres termes, dans le code d'appel que je veux:

int foo(int const **ppTargets) {
    int const * const pTargets = /* calculate here */;
    *ppTargets = pTargets;
    return 37; // just e.g.
}

Pour tout type T , le type d'un pointeur vers un T peut être orthographié T * . En particulier, le type de ce & pTargets est int const ** (vous semble familier?), Et c'est le type approprié pour un paramètre de fonction à travers lequel la fonction devrait être en mesure de définir la valeur des pTargets de l'appelant .

Et encore une fois, appeler foo () pour lui demander de définir la valeur des pTargets de l'appelant semble être exactement le point. Si foo () était censé être empêché de le faire, alors l'approche idéale serait de passer pTargets lui-même (par valeur), au lieu de passer son adresse et de se disputer const qualificatifs.

Après les entrées des autres, en particulier la règle Clockwise / Spiral par @Mahesh, ainsi que quelques débats, j'ai compris comment lire et écrire facilement de telles choses.

Nous devrions examiner ce qui peut et ce qui ne peut pas être modifié. Considérez donc la déclaration sans const s: int ** ppTargets . Nous voulons que ppTargets ne puisse pas être modifié lui-même, tandis que * pTargets peut être modifié, tandis que ** pTargets ne peut pas être modifié.

Ensuite, appliquez ces observations de droite à gauche: int const * * const ppTargets .

Le const le plus à droite indique que ppTargets ++ n'est pas possible.

Ensuite, l'absence de const au milieu indique que (* ppTargets) = pTargets est possible.

Puis un autre const le plus à gauche dit que (** ppTargets) ++ n'est pas possible.

La formalisation de base pour l'indirection est à mon avis

int foo(const int* const* const p);

{// equal leftmost qualifier
const int* p = nullptr;

const int** p1 = &p; // 2nd and 3rd qualifiers are less restrictive
foo(p1);

const int* const* p2 = &p; // 2nd qualifier is equal, 3rd one (implicit read-write) is less restrictive
foo(p2);

const int* const* const p3 = &p; // 2nd and 3rd qualifiers are equal
foo(p3);
}

{// less restrictive leftmost qualifier of p
int* p = nullptr;

int** p1 = &p; // 2nd and 3rd qualifiers are less restrictive
foo(p1); 

int* const* p2 = &p; // 2nd qualifier is equal, 3rd one (implicit read-write) is less restrictive
foo(p2);

int* const* const p3 = &p; // 2nd and 3rd qualifiers are equal
foo(p3);
}

où est lui-même une zone mémoire. Pour une double indirection, l'expression devient

(read-only|read-write) <memory zone> * (read-only|read-write) <memory zone/pointer-level2> * (read-only|read-write) <pointer-level1>

Ce qui rend les choses plus difficiles à comprendre, c'est la possibilité de placer des qualificatifs (par exemple. lecture seule ) avant OU après sur la taille de gauche du symbole * . Sur le côté droit du symbole * , le ou les qualificatifs peuvent être placés uniquement avant .

En C ++, lecture seule signifie const et lecture-écriture est le qualificatif implicite.

Ainsi on peut avoir:

• char * p pointeur de lecture-écriture vers la zone de mémoire char lecture-écriture
• const char * p pointeur en lecture-écriture vers la zone de mémoire lecture seule char
• char * const p lecture seule pointeur vers la zone mémoire char lecture-écriture
• const char * const p lecture seule pointeur vers lecture seule char zone mémoire li >

Ensuite, nous pouvons déplacer const après le type de base résultant des déclarations équivalentes:

• char const * p pointeur en lecture-écriture vers la zone de mémoire lecture seule char
• char const * const p lecture seule pointeur vers lecture seule char zone de mémoire li >

La conversion de pointeur est autorisée avec un qualificatif égal ou un qualificatif moins restrictif dans le pointeur source pour chaque niveau d'indirection par rapport au pointeur de destination.

En conséquence, les cas suivants sont valides:

(read-only|read-write) <memory zone> * (read-only|read-write) <pointer>

Dans votre cas, le qualificatif le plus à gauche du pointeur passé en argument ( & pTargets ) n'est pas égal ou moins restrictif que le qualificatif le plus à gauche du pointeur de Fonction foo .