je ne comprends pas pourquoi le code suivant ne compile pas :
void foo(const int ** param);
int ** p;
foo(p); // Ne compile pas...
g++ me dit que ne pas convert un 'int**' vers un 'const int**'.
D'ailleurs, si je déclare un 'const int ** p', qu'est-ce qui est const?
Les pointeurs eux même (par ex. je n'ai pas le droit de faire
'p[0]=NULL')? Ou alors les données sous les pointeurs de pointeurs (par
ex. je n'ai pas le droit de faire 'p[0][0]=10')?
Et est-il possible de déclarer un pointeur const de pointeur const? De
telle sorte d'interdire 'p[0]=NULL' et 'p[0][0]=10'.
Cette action est irreversible, confirmez la suppression du commentaire ?
Signaler le commentaire
Veuillez sélectionner un problème
Nudité
Violence
Harcèlement
Fraude
Vente illégale
Discours haineux
Terrorisme
Autre
Michel Decima
Bonjour à tous,
je ne comprends pas pourquoi le code suivant ne compile pas :
void foo(const int ** param);
int ** p; foo(p); // Ne compile pas...
g++ me dit que ne pas convert un 'int**' vers un 'const int**'.
je ne sais pas, j'aurais pensé aussi que ca devait compiler, mais je n'utilise presque jamais des pointeurs de pointeurs, il y a peut etre une subtilité qu im'echappe.
D'ailleurs, si je déclare un 'const int ** p', qu'est-ce qui est const? Les pointeurs eux même (par ex. je n'ai pas le droit de faire 'p[0]=NULL')? Ou alors les données sous les pointeurs de pointeurs (par ex. je n'ai pas le droit de faire 'p[0][0]')?
Tu declares un pointeur vers des pointeurs vers des donnees constantes. (2eme cas). Pour s'en sortir, il y aune astuce qui consiste a placer le const apres le type auquel il se rapporte, et lire la declaration de droite a gauche:
int const ** p;
(une autre solution: ne pas utiliser de pointeurs de pointeurs, mais ce n'est pas le sujet).
Et est-il possible de déclarer un pointeur const de pointeur const? De telle sorte d'interdire 'p[0]=NULL' et 'p[0][0]'.
int const* const* p;
correspond au interdictions, mais c'est un pointeur (non const) vers des pointeurs const vers des donnees const. Si tu veux que le pointeur p lui meme soit const, alors c'est :
int const* const* const p;
Bonjour à tous,
je ne comprends pas pourquoi le code suivant ne compile pas :
void foo(const int ** param);
int ** p;
foo(p); // Ne compile pas...
g++ me dit que ne pas convert un 'int**' vers un 'const int**'.
je ne sais pas, j'aurais pensé aussi que ca devait compiler, mais
je n'utilise presque jamais des pointeurs de pointeurs, il y a peut etre
une subtilité qu im'echappe.
D'ailleurs, si je déclare un 'const int ** p', qu'est-ce qui est const?
Les pointeurs eux même (par ex. je n'ai pas le droit de faire
'p[0]=NULL')? Ou alors les données sous les pointeurs de pointeurs (par
ex. je n'ai pas le droit de faire 'p[0][0]')?
Tu declares un pointeur vers des pointeurs vers des donnees constantes.
(2eme cas). Pour s'en sortir, il y aune astuce qui consiste a placer le
const apres le type auquel il se rapporte, et lire la declaration de
droite a gauche:
int const ** p;
(une autre solution: ne pas utiliser de pointeurs de pointeurs, mais ce
n'est pas le sujet).
Et est-il possible de déclarer un pointeur const de pointeur const? De
telle sorte d'interdire 'p[0]=NULL' et 'p[0][0]'.
int const* const* p;
correspond au interdictions, mais c'est un pointeur (non const) vers des
pointeurs const vers des donnees const. Si tu veux que le pointeur p lui
meme soit const, alors c'est :
je ne comprends pas pourquoi le code suivant ne compile pas :
void foo(const int ** param);
int ** p; foo(p); // Ne compile pas...
g++ me dit que ne pas convert un 'int**' vers un 'const int**'.
je ne sais pas, j'aurais pensé aussi que ca devait compiler, mais je n'utilise presque jamais des pointeurs de pointeurs, il y a peut etre une subtilité qu im'echappe.
D'ailleurs, si je déclare un 'const int ** p', qu'est-ce qui est const? Les pointeurs eux même (par ex. je n'ai pas le droit de faire 'p[0]=NULL')? Ou alors les données sous les pointeurs de pointeurs (par ex. je n'ai pas le droit de faire 'p[0][0]')?
Tu declares un pointeur vers des pointeurs vers des donnees constantes. (2eme cas). Pour s'en sortir, il y aune astuce qui consiste a placer le const apres le type auquel il se rapporte, et lire la declaration de droite a gauche:
int const ** p;
(une autre solution: ne pas utiliser de pointeurs de pointeurs, mais ce n'est pas le sujet).
Et est-il possible de déclarer un pointeur const de pointeur const? De telle sorte d'interdire 'p[0]=NULL' et 'p[0][0]'.
int const* const* p;
correspond au interdictions, mais c'est un pointeur (non const) vers des pointeurs const vers des donnees const. Si tu veux que le pointeur p lui meme soit const, alors c'est :
int const* const* const p;
Jean-Marc Bourguet
Guillaume GOURDIN writes:
Bonjour à tous,
je ne comprends pas pourquoi le code suivant ne compile pas :
void foo(const int ** param);
int ** p; foo(p); // Ne compile pas...
g++ me dit que ne pas convert un 'int**' vers un 'const int**'.
Normal. Ca permettrait ce genre de chose:
int const i = 42; int* pi; int const** pci = π *pci = &i; *pi = 36; /* on modifie i! */
D'ailleurs, si je déclare un 'const int ** p', qu'est-ce qui est const?
const int** p c'est la meme chose que int const** p, c'est l'int qui est constant.
Et est-il possible de déclarer un pointeur const de pointeur const? De telle sorte d'interdire 'p[0]=NULL' et 'p[0][0]'.
je ne comprends pas pourquoi le code suivant ne compile pas :
void foo(const int ** param);
int ** p; foo(p); // Ne compile pas...
g++ me dit que ne pas convert un 'int**' vers un 'const int**'.
Normal. Ca permettrait ce genre de chose:
int const i = 42; int* pi; int const** pci = π *pci = &i; *pi = 36; /* on modifie i! */
D'ailleurs, si je déclare un 'const int ** p', qu'est-ce qui est const?
const int** p c'est la meme chose que int const** p, c'est l'int qui est constant.
Et est-il possible de déclarer un pointeur const de pointeur const? De telle sorte d'interdire 'p[0]=NULL' et 'p[0][0]'.
int *const *const x
A+
-- Jean-Marc
IR
Guillaume GOURDIN wrote:
g++ me dit que ne pas convert un 'int**' vers un 'const int**'.
S'il le faut vraiment (et ce malgré la démonstration de Jean Marc quant à la dangerosité d'une telle conversion), const_cast fait l'affaire:
int ** p; foo(const_cast<const int**>(p));
Si foo fait partie intégrante de ton code, j'aurais tendance à suggérer de revoir le design (IMHO T** c'est au moins une indirection de trop, il y a moyen d'encapsuler tout ça un peu plus proprement, ne serait-ce que grâce à std::vector<int*>, voire même std::vector< std::vector<int> >).
Par contre si foo fait partie d'une lib externe, et/ou si c'est une fonction C, eh bien, c'est pas comme s'il tu avais le choix... ;-) (quoique le std::vector<int*> est quand même utilisable même dans ces cas là).
-- IR
Guillaume GOURDIN wrote:
g++ me dit que ne pas convert un 'int**' vers un 'const int**'.
S'il le faut vraiment (et ce malgré la démonstration de Jean Marc
quant à la dangerosité d'une telle conversion), const_cast fait
l'affaire:
int ** p;
foo(const_cast<const int**>(p));
Si foo fait partie intégrante de ton code, j'aurais tendance à
suggérer de revoir le design (IMHO T** c'est au moins une
indirection de trop, il y a moyen d'encapsuler tout ça un peu plus
proprement, ne serait-ce que grâce à std::vector<int*>, voire même
std::vector< std::vector<int> >).
Par contre si foo fait partie d'une lib externe, et/ou si c'est une
fonction C, eh bien, c'est pas comme s'il tu avais le choix... ;-)
(quoique le std::vector<int*> est quand même utilisable même dans ces
cas là).
g++ me dit que ne pas convert un 'int**' vers un 'const int**'.
S'il le faut vraiment (et ce malgré la démonstration de Jean Marc quant à la dangerosité d'une telle conversion), const_cast fait l'affaire:
int ** p; foo(const_cast<const int**>(p));
Si foo fait partie intégrante de ton code, j'aurais tendance à suggérer de revoir le design (IMHO T** c'est au moins une indirection de trop, il y a moyen d'encapsuler tout ça un peu plus proprement, ne serait-ce que grâce à std::vector<int*>, voire même std::vector< std::vector<int> >).
Par contre si foo fait partie d'une lib externe, et/ou si c'est une fonction C, eh bien, c'est pas comme s'il tu avais le choix... ;-) (quoique le std::vector<int*> est quand même utilisable même dans ces cas là).
