Différence de déclarations avec "const"

Bonjour,

je me souviens d'un sujet (que je ne retrouve plus) où il y avait une explication des différentes déclarations :

Code:

---

1 2 3

const char * pt_word; char * const pt_word; const char * const pt_word;

---

si quelqu'un peut donner plus d'informations sur ces déclarations (si elles existent toutes).
Merci

http://www.developpez.net/forums/d11...on-char-const/ celui-ci ? :)

Citation:

---

Envoyé par Bktero

http://www.developpez.net/forums/d11...on-char-const/ celui-ci ? :)

---

Très bon sujet aussi pour l'info qu'il contient, mais ce n'est pas celui-ci.
Je me souviens particulièrement d'une personne qui expliquait justement la portée du const suivant qu'il se trouvait à gauche ou à droite d'un mot.

http://www.developpez.net/forums/d11...er/const-char/

ou

http://www.developpez.net/forums/d11...buter/const-c/

?

Code:

---

1 2 3

const char * pt_word; // pointeur non constant sur une donnée constante char * const pt_word; // pointeur constant sur une donnée non constante const char * const pt_word; // pointeur constant sur une donnée constante

---

Bonjour,

Citation:

---

Envoyé par MicBeastKiller

Bonjour,

je me souviens d'un sujet (que je ne retrouve plus) où il y avait une explication des différentes déclarations :

---

Celui-ci, peut-être : http://www.developpez.net/forums/d12...r/#post6683664
Mais il se trouve dans le forum C++.

Citation:

---

Envoyé par Obsidian

Bonjour,
Celui-ci, peut-être : http://www.developpez.net/forums/d12...r/#post6683664
Mais il se trouve dans le forum C++.

---

C'était sûrement celui-ci.
Il y a en tout cas toutes les explications.
Merci à tous.

Faudra juste vérifier les corrections apportées dans l'avant-dernier message ;)

Dans n1256, il y a l'exemple donné au point 28 de la partie 6.2.5 Types qui est intéressant :

Citation:

---

EXAMPLE 1 The type designated as ‘‘float *’’ has type ‘‘pointer to float’’. Its type category is
pointer, not a floating type. The const-qualified version of this type is designated as ‘‘float * const’’
whereas the type designated as ‘‘const float *’’ is not a qualified type — its type is ‘‘pointer to constqualified
float’’ and is a pointer to a qualified type.

---

Il y en a un autre dans la partie 6.7.5.1 Pointer declarators, au point 3 :

Citation:

---

EXAMPLE The following pair of declarations demonstrates the difference between a ‘‘variable pointer
to a constant value’’ and a ‘‘constant pointer to a variable value’’.

Code:

---

1 2	const int *ptr_to_constant; int *const constant_ptr;

---

The contents of any object pointed to by ptr_to_constant shall not be modified through that pointer,
but ptr_to_constant itself may be changed to point to another object. Similarly, the contents of the
int pointed to by constant_ptr may be modified, but constant_ptr itself shall always point to the
same location.

---

suivi par le point 4 :

Citation:

---

The declaration of the constant pointer constant_ptr may be clarified by including a definition for the
type ‘‘pointer to int’’.
typedef int *int_ptr;
const int_ptr constant_ptr;
declares constant_ptr as an object that has type ‘‘const-qualified pointer to int’’.

---

Citation:

---

Envoyé par Bktero

Faudra juste vérifier les corrections apportées dans l'avant-dernier message ;)

---

En fait, je vais faire référence à ce message :
http://www.developpez.net/forums/d11...buter/const-c/

Par contre je ne peux faire de cette manière là :

Code:

---

1 2 3 4

int maFonction( int unEntier const , char * unMot const ) { /* code */ }

---

mettre le "const" à la fin ?

Citation:

---

Envoyé par MicBeastKiller

Par contre je ne peux faire de cette manière là :

Code:

---

1 2 3 4

int maFonction( int unEntier const , char * unMot const ) { /* code */ }

---

mettre le "const" à la fin ?

---

Non, car const "porte" sur ce qu'il suit, c'est a dire rien dans le cas que tu cites.

Visiblement non :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14

int f(int const p1, int p2 const) { return p1 + p2; }   int main(void) { const int a = 2; int const b = 3;   //int c const = 4; // invalide   return f(a,b); }

---

Me dit que f est implicitement déclarée à l'avant-dernière ligne.

EDIT : en compilant en C++, il y a une erreur lors de la déclaration de la fonction f().

EDIT 2 : en compilant en C avec l'option -pedantic, la définition de la fonction génère aussi une erreur.

Citation:

---

Envoyé par gangsoleil

Non, car const "porte" sur ce qu'il suit, c'est a dire rien dans le cas que tu cites.

---

Or cela est possible pour déclarer des variables ?

Code:

---

1 2	int unEntier const; char * unMot const;

---

Citation:

---

Envoyé par MicBeastKiller

Or cela est possible pour déclarer des variables ?

Code:

---

1 2	int unEntier const; char * unMot const;

---

---

Non, voir mon code précédent : en dé-commentant la ligne commentée, il y a un erreur de compilation.

Citation:

---

Envoyé par gangsoleil

Non, car const "porte" sur ce qu'il suit, c'est a dire rien dans le cas que tu cites.

---

on peut juste inverser const et le type comme le montre le code suivant :

Code:

---

1 2 3 4 5 6 7 8 9 10

int main(void) { const int a = 2; int const b = 3;   const int * p1 = malloc(sizeof(int)); int const * p2 = malloc(sizeof(int));   return 0; }

---

Citation:

---

Envoyé par Bktero

Non, voir mon code précédent : en dé-commentant la ligne commentée, il y a un erreur de compilation.

---

Ce n'est donc pas permis (du moins en C).

Citation:

---

Envoyé par Bktero

pour les pointeurs, on peut inverser const et le type comme le montre le code suivant :

Code:

---

1 2 3 4 5 6 7 8 9 10 11

int main(void) { const int * p1 = malloc(sizeof(int)); int const * p2 = malloc(sizeof(int));   p1 = p2; p2 = p1;   *p1 = 1; *p2 = 2; }

---

---

C'est d'ailleurs ce qui est indiqué dans tous les liens fournis précédemment.

Merci en tout cas de vos réponses.

Citation:

---

Envoyé par MicBeastKiller

Ce n'est donc pas permis (du moins en C).

---

Ni en C++ visiblement.

Citation:

---

Envoyé par MicBeastKiller

Merci en tout cas de vos réponses.

---

De rien :)

Citation:

---

Envoyé par Bktero

Ni en C++ visiblement.

---

Alors certains points de ceci ne sont pas corrects ?
http://www.developpez.net/forums/d12...r/#post6683664

Contrairement à ce qui a été dit plus haut et dans d'autre messages, je trouve plus simple de considérer que ce qui est constant, c'est ce qui suit le "const". Par exemple :

Code:

---

1 2 3 4

int const *p; /* *p est constant */ int * const p; /* p est constant */ int const **p; /* **p est constant */ int const * const *p; /* *p et **p sont constants */

---

Et d'autre part, "const T" est équivalent "T const", d'où il découle que l'écriture classique "const int *p" est équivalent à "int const *p" décrit plus haut.

const agit sur le type de données et sur l'élément à sa gauche, sauf exception quand il est en premier et agit à sa droite
cf mon premier message plus haut
et sachant ceci

Code:

---

1 2 3 4 5 6 7 8

// les 2 déclarations sont équivalentes const int constint; int const intconst; int myint const; // n'a absolument aucun sens int const* constintptr; // les 2 déclarations sont équivalentes int const* const constintconstptr; const int* const constintptrconst;

---

en C le seul intérêt est pour const int/float/... * puisque de toutes façons tous les passages en paramètres se font par copie.
passer un int ou un const int n'a aucune incidence.

Citation:

---

Envoyé par MicBeastKiller

Alors certains points de ceci ne sont pas corrects ?
http://www.developpez.net/forums/d12...r/#post6683664

---

Comme je l'avais dit dans un message que tu as toi-même cité :

Citation:

---

Faudra juste vérifier les corrections apportées dans l'avant-dernier message

---

D'ailleurs, j'ai relancé le sujet en question.

Ce que tu dis et ce que dis revient au même. Par exemple, si tu as "int const *p", toi tu dis "c'est le int qui est const". Moi je dis, "c'est *p qui est const". C'est la même chose, puisque c'est bien *p qui est un int. Dans une déclaration ce qui est à droite d'un truc est du type à gauche du truc.

Je dis seulement que je trouve ma méthode plus simple à utiliser, car tout ce que tu as besoin de savoir c'est que tu ne peux rien affecter à tout ce qui ce trouve à droite du const. Si tu as "int const *p", tu ne peux pas écrire "*p = X".

Citation:

---

Envoyé par Bousk

en C le seul intérêt est pour const int/float/... * puisque de toutes façons tous les passages en paramètres se font par copie.
passer un int ou un const int n'a aucune incidence.

---

Cela signifie donc que dans la fonction suivante :

Code:

---

1 2 3 4

int uneFonction( int const unEntier ) {   }

---

le "const" est inutile car la "uneFonction" fera une copie de "unEntier" ?

Pas exactement.

En C, les fonctions prennent les paramètres par valeur. C'est-à-dire que quand tu passes a en paramètre de f(), la fonction travaille sur une copie de a et toutes les modifications faites sur cette variable à l'intérieur de f() seront perdues en sortie. En effet, la durée de vie de la copie est égale à la durée de la fonction.

En revanche, tu peux passer un paramètre en l'indiquant constant. Cela t'interdira de modifier son contenu. Même pour un int ce n'est pas très utile, ce n'est pas forcément bête pour ne pas modifier la copie "par mégarde" et faire des calculs "faux" dans la fonction.

Essaye de compiler ce code :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

void incremente(int nb) { nb++; }   void donttouch(const int nb) { nb++; }   int main(void) { int a = 2;   incremente(a); printf("a = %d\n", a);   donttouche(a); printf("a = %d\n", a);   return 0; }

---

Puis, modifier la ligne qui donne l'erreur par nb; et regarde la sortie en console.

Citation:

---

Envoyé par Bktero

Pas exactement.

En C, les fonctions prennent les paramètres par valeur. C'est-à-dire que quand tu passes a en paramètre de f(), la fonction travaille sur une copie de a et toutes les modifications faites sur cette variable à l'intérieur de f() seront perdues en sortie. En effet, la durée de vie de la copie est égale à la durée de la fonction.

En revanche, tu peux passer un paramètre en l'indiquant constant. Cela t'interdira de modifier son contenu. Même pour un int ce n'est pas très utile, ce n'est pas forcément bête pour ne pas modifier la copie "par mégarde" et faire des calculs "faux" dans la fonction.

---

Je retiens cela qui me semble très important.
Merci beaucoup pour ton explication

De rien ;).


Pour terminer, comme j'ai dit que ce n'était pas très utile pour un simple int, voici un exemple avec une int*. Tu empêches ainsi de modifier la zone pointée, car la modification resterait après la fonction :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22

void touchme(int *pt_nb) { *pt_nb = 42; }   void donttouch(const int * pt_nb) { *pt_nb = 66; // enlever l'étoile pour que ça compile }   int main(void) { int a = 2;   touchme(&a); printf("a = %d\n", a);   donttouche(&a); printf("a = %d\n", a);   return 0; }

---

Ici, la fonction travaille sur une copie de l'adresse de a (il crée une nouvelle variable de type pointeur sur int qui prend la valeur de &a) mais cette adresse (copiée ou pas) donne toujours accès à a.