C question de const

Question

Si je fais ceci:

// In header 
class Foo { 
void foo(bar*); 
}; 

// In cpp 
void Foo::foo(bar* const pBar) { 
//Stuff 
} 

Le compilateur ne se plaint pas que les signatures pour Foo :: foo ne correspondent pas. Toutefois, si j'avais:

void foo(const bar*); //In header 
void Foo::foo(bar*) {} //In cpp 

Le code ne pourra pas être compilé.

Que se passe-t-il? J'utilise gcc 4.1.x

Answer 1

Le mot-clé const dans le premier exemple n'a pas de sens. Vous dites que vous ne prévoyez pas de changer le pointeur. Cependant, le pointeur a été passé par valeur et donc cela n'a pas d'importance si vous le modifiez ou non; cela n'affectera pas l'appelant. De même, vous pouvez aussi le faire:

// In header 
class Foo { 
void foo(int b); 
}; 

// In cpp 
void Foo::foo(const int b) { 
//Stuff 
} 

Vous pouvez même le faire:

// In header 
class Foo { 
void foo(const int b); 
}; 

// In cpp 
void Foo::foo(int b) { 
//Stuff 
} 

Depuis le int est passé par valeur, le constness n'a pas d'importance.

Dans le deuxième exemple, vous dites que votre fonction prend un pointeur sur un type, mais l'implémente comme un pointeur sur un autre type, donc il échoue.

Answer 2

Dans la première, vous avez promis le compilateur, mais pas les autres utilisateurs de la classe que vous ne modifierez pas la variable.

Dans votre deuxième exemple, vous avez promis d'autres utilisateurs de la classe que vous ne modifieront pas leur variable, mais n'a pas respecté cette promesse.

Il faut aussi noter qu'il ya une nette différence entre

bar* const variable 

et

const bar* variable 

et

const bar* const variable 

Dans la première forme, le pointeur ne changera jamais, mais vous pouvez éditer l'objet pointé. Dans la deuxième forme, vous pouvez éditer le pointeur (pointer vers un autre objet), mais jamais la variable vers laquelle il pointe. Dans la forme finale, vous ne modifierez pas le pointeur, ni l'objet vers lequel il pointe. Reference

Pour ajouter un peu plus d'une précision à la question posée, vous pouvez toujours promettre plus que moins const. Étant donné une classe:

class Foo { 
    void func1 (int x); 
    void func2 (int *x); 
} 

Vous pouvez compiler la mise en œuvre suivante:

Foo::func1(const int x) {} 
Foo::func2(const int *x) {} 

ou:

Foo::func1(const int x) {} 
Foo::func2(const int* const x) {} 

sans aucun problème. Vous avez indiqué à vos utilisateurs que vous pouvez éventuellement modifier leurs variables. Dans votre implémentation, vous avez dit au compilateur que cette implémentation particulière n'éditerait pas ces variables, même si cela était indiqué aux utilisateurs. Vous n'avez pas rompu une promesse à l'utilisateur, et donc le code compile.

Answer 3

Dans le premier, l'const n'affecte pas l'interface, seule la mise en œuvre. Vous dites au compilateur, « Je ne vais pas changer la valeur de la bar* au sein de cette fonction ». Vous pouvez toujours changer ce qui est pointé par le pointeur. Dans ce dernier, vous dites au compilateur (et tous les appelants) que vous ne changerez pas la structure bar que les bar*points.

Answer 4

Voir this question, this question et this question.

Fondamentalement, le const signifie seulement que la fonction ne modifiera pas la valeur du pointeur. Le contenu des pointeurs n'est pas const, identique à la signature de l'en-tête.

Answer 5

Ainsi, le deuxième const:

void Foo::foo(const bar* const); 

est pas partie de la signature de la méthode?

Answer 6

Ceci est plus simple à comprendre avec un type de variable autre qu'un pointeur. Par exemple, vous pouvez avoir la déclaration de fonction suivante:

void foo(int i); 

La définition peut ressembler à ceci:

void foo(const int i) { ... } 

si la variable « i » est const ou non du côté de la définition est un détail de mise en œuvre . Cela n'a aucun impact pour les clients de cette fonction.

Answer 7

Il ne se soucie probablement pas beaucoup de void Foo::foo(bar* const pBar) parce que la façon dont vous traitez le pointeur lui-même (const ou non) n'a pas d'importance un bit en dehors de la routine. Les règles C indiquent qu'aucun changement de pBar ne se fera en dehors de foo. Cependant, s'il s'agit de (const bar* pBar), cela fait une différence, car cela signifie que le compilateur ne doit pas permettre aux appelants de passer dans des pointeurs vers des objets non const.