Discussion :

[matafan]

En C, il n'est pas possible de passer à une fonction

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

void f(T const * const * a)

un argument d'un des types suivants :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
T * * a;
T * const * b;
T * * const c;

En fait, pour pouvoir appeler la fonction f, il faut faut au moins que le paramètre passé soit de type :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

T const * * d;

C'est à dire, pointeur vers un pointeur vers un const.

Pourquoi ? Quel danger y a-t-il à passer a, b ou c à ma fonction f ?

En fait cette restriction en C me parrait étrange car il n'y a à mon avis danger à passer mes pointeurs a, b ou c à ma fonction f, car ma fonction est "plus const" que mes variables a, b et c.

Mais, puisque le C interdit le passage d'une variable non const ** à une fonction const * const *, j'imagine qu'il y a une bonne raison, qui m'échappe. Si quelqu'un connait cette raison, j'aimerai qu'il me la présente.

[Médinoc]

Alors, côté explication:

1. a et c, c'est pareil (passage par copie).
2. Le problème de a est un problème connu du C, résolu en C++.
   En fait, le C considère T* et T const * comme deux types différents (ce qu'ils sont), et donc T * const * et T const * const * sont à ses yeux des pointeurs vers des types différents. Je suppose que la source du problème est un problème de covariance/contravariance.
   (Note: Je rappelle que le const que j'ai mis en italique est obligatoire: Convertir un T ** en T const ** poserait un problème de const-correctness).
3. Pour b, je suppose que c'est pareil.

Le C++ autorise le cast implicite de T** en T const * const *, et c'est bien pratique. Le compilateur C de Visual Studio le supporte aussi en tant qu'extension, mais ne le reconnait pas comme une extension (puisque c'est toujours actif même avec le flag /Za).

[matafan]

Mais la vraie question est, pourquoi ne peut-on pas affecter une variable de type T * const * à une variable de type T const * const * sans déclancher un warning, alors qu'on peut affecter sans warning une variable de type T * à une variable de type T const * ?

D'une autre côté c'est vrai que ce ne sont que des warnings, et l'affectation est en fait permise malgré tout. Mais si on veut enlever ce warning il faut caster, ce qui est finalement beaucoup plus dangereux. Ce n'est donc pas seulement un warning inutile, c'est un warning dangereux.

[Médinoc]

Mais la vraie question est, pourquoi ne peut-on pas affecter une variable de type T * const * à une variable de type T const * const * sans déclancher un warning, alors qu'on peut affecter sans warning une variable de type T * à une variable de type T const * ?

L'ajout de const au premier niveau de pointeur est explicitement autorisée et facile à reconnaître. L'ajout de const aux niveaux suivants est plus complexe. Comme je l'ai dit, en C++ ça marche. Mais j'ignore pourquoi cela n'a pas été ajouté dans les derniers standards du C...[/QUOTE]

[Jean-Marc.Bourguet]

La regle du C++ est relativement compliquee, le comite C a decide d'avoir une regle plus simple, mais interdisant des cas valides.

Dans le cas present:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
char * const * p1;
char const * const * p2;
 
p2 = p1

n'est pas conforme en C et l'est en C++.

Un cas fort similaire qui est interdit dans les deux langages:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
char ** p1;
char const ** p2;
 
p2 = p1;

parce que la sequence suivante serait valide mais modifierait c:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
char const c = 'C';
char* p3;
char ** p1 = &p3;
char const ** p2 = p1;
*p2 = &c; // oops, p3 vaut &c
*p3 = 'B';