Explication de l'utilisation des const C ++

const int* const Method3(const int* const&) const;

Quelqu'un peut-il expliquer l'utilisation de chacun des const?

Lisez ceci: https://isocpp.org/wiki/faq/const-correctness

Le final constsignifie que la fonction Method3ne modifie pas les membres non mutables de sa classe.

const int* constsignifie un pointeur constant vers une constante int: c'est-à-dire un pointeur non modifiable, vers un int non modifiable: la seule différence entre this et const int&est qu'il peut êtrenull

const int* const&signifie une référence à un pointeur constant vers une constante int. En général, les pointeurs ne sont pas passés par référence; const int* &a plus de sens car cela signifierait que le pointeur pourrait être changé pendant l'appel de méthode, ce qui serait la seule raison pour laquelle je peux voir pour passer un pointeur par référence, const int* const&est à toutes fins utiles le même que const int* constsauf qu'il est probablement moins efficace car les pointeurs sont des types de données anciennes (POD) et ceux-ci devraient, en général, être passés par valeur.

C'est plus facile à comprendre si vous réécrivez cela comme l'équivalent complètement

// v───v───v───v───v───v───v───v───v───v───v───v─┬┐
//                                               ││
//  v──#1    v─#2             v──#3    v─#4      #5
   int const * const Method3(int const * const&) const;

puis lisez-le de droite à gauche.

# 5 dit que la déclaration de fonction entière à gauche est const, ce qui implique qu'il s'agit nécessairement d'une fonction membre plutôt que d'une fonction libre.

# 4 indique que le pointeur à gauche est const(ne peut pas être changé pour pointer vers une adresse différente).

# 3 indique que le intà gauche est const(ne peut pas être changé pour avoir une valeur différente).

# 2 indique que le pointeur à gauche est const.

# 1 dit que le intvers la gauche est const.

En mettant tout cela ensemble, vous pouvez lire ceci comme une constfonction membre nommée Method3qui prend une référence à un constpointeur vers un int const(ou a const int, si vous préférez) et renvoie un constpointeur vers un int const( const int).

(Le n ° 2 est entièrement superflu .)

Tout d'abord const Téquivaut à T const.

const int* constéquivaut donc à int const * const.

Lorsque vous lisez des expressions contenant de nombreux constjetons et pointeurs, essayez toujours de les lire de droite à gauche (après avoir appliqué la transformation ci-dessus). Donc, dans ce cas, la valeur de retour est un pointeur const vers un constint . Faire le pointeur lui-même constn'a aucun sens ici car la valeur de retour n'est pas une lvalue qui pourrait être modifiée. Faire le pointe const, cependant, garantit que l'appelant ne peut pas modifier le int(ou le tableau de ints) renvoyé par Method3.

const int*const&devient int const*const&, donc c'est une référence à un pointeur const vers un constint . Passer un pointeur const par des références mâles n'a aucun sens non plus - vous ne pouvez pas modifier la valeur référencée car le pointeur est constet les références et les pointeurs occupent un stockage égal, donc il n'y a pas non plus d'économie d'espace.

Le dernier constindique que la méthode ne modifie pas l' thisobjet. Le thispointeur dans le corps de la méthode aura la déclaration (théorique) T const * const this. Cela signifie qu'un const T*objet pourra appeler T::Method3().

Un moyen facile de se souvenir des règles de constest de le penser de cette façon: consts'applique à la chose à sa gauche, à moins qu'il n'y ait rien à sa gauche.

Donc, dans le cas de const int * const, le premier const n'a rien à sa gauche, donc il s'applique à intet le second a quelque chose à sa gauche, donc il s'applique au pointeur.

Cette règle vous indique également ce qui se passerait dans le cas où vous en avez const int const *. Étant donné que les deux const s'appliquent à intcette expression, elle est redondante et donc invalide.

const /* don't modify the int or array of ints' value(s) */
int* const /* as a retval, ignored. useless declaration */
Method3(const /* don't modify the int or array of ints' value(s) */
int* const /* don't modify the pointer's value, the address to which `pointer` points to. e.g. you cannot say `++pointer` */
&) const; /* this method does not modify the instance/object which implements the method */

J'aime utiliser la méthode "horloge" ou "spirale" où, à partir du nom de l'identifiant (dans ce cas Method3), vous lisez d'avant en arrière de gauche à droite, d'arrière à gauche, etc. afin de décoder conventions de nommage. Il en const int* const Method3(const int* const&) constva de même pour une méthode de classe qui ne change aucun membre de classe (d'une classe sans nom) et prend une référence constante à un pointeur qui pointe vers une constante intet retourne un pointeur de constante vers une constante int.

J'espère que cela t'aides,

Jason

Un moyen simple de se souvenir du const en C ++ est de voir du code sous une forme comme:

XXX const;
const YYY;

XXX, YYY sera un composant constant, de la
XXX constforme:

function ( def var ) const;    ------#1
* const;                       ------#2

const YYY forme:

const int;                     ------#3
const double;

Les gens utilisent généralement ces types. Quand vous voyez "const&"quelque part, ne vous sentez pas confus, const décrit quelque chose avant lui-même. la réponse à ce problème est donc évidente maintenant.

const int* const Method3(const int* const&) const;
  |          |             |          |       |
  #3         #2            #3         #2      #1

Je veux seulement mentionner que const int* const&c'est effectivement une référence constante à const int*. Par exemple:

int i = 0;
int j = 1;
int* p = &i;
int* q = &j;
const int* const& cpref = p;
cpref = q; //Error: assignment of read-only reference 'cpref'

C'est aussi le cas pour int* const&, ce qui signifie: "Une référence constante à int*".
Mais const int*&est une référence non constante à const int*.
J'espère que cela t'aides.

La lecture de droite à gauche facilite la compréhension des modificateurs.

Une méthode const qui prend une référence à un pointeur const vers un const int appelé Method3qui retourne un pointeur const vers un const int.

1. Une méthode const ne peut pas modifier les membres (à moins qu'ils ne le soient expressément mutable)
2. Un pointeur const ne peut pas être changé pour pointer vers autre chose
3. Un const int (ou tout autre type) ne peut pas être modifié

const # 1: Le pointeur retourné par Method3 fait référence à un const int.

const # 2: La valeur du pointeur renvoyée par la fonction, elle-même, est const. C'est un const inutile (bien que grammaticalement valide), car la valeur de retour d'une fonction ne peut pas être une valeur l.

const # 3: Le type de pointeur passé par référence à la fonction pointe vers un const int.

const # 4: La valeur du pointeur passée par référence à la fonction est elle-même un pointeur const. Déclarer une valeur qui est passée à une fonction comme const serait normalement inutile, mais cette valeur est passée par référence, donc elle peut être significative.

const # 5: La fonction (vraisemblablement une fonction membre) est const, ce qui signifie qu'elle n'est pas autorisée à (a) attribuer de nouvelles valeurs à des membres de l'objet dont elle fait partie ou (b) appeler une fonction membre non-const sur l'objet ou sur l'un de ses membres.

• const à la fin de la méthode se trouve le qualificatif signifiant que l'état de l'objet ne va pas être changé.

• const int*const&signifie recevoir par référence un pointeur const vers un emplacement const. Il ne peut ni changer pour pointer vers un emplacement différent ni changer la valeur vers laquelle il pointe.

• const int*const est la valeur de retour qui est également un pointeur constant vers un emplacement constant.

Quelques exemples pourraient être intéressants pour illustrer ce concept, plus il y en a, mieux c'est.

class TestClass
{
private:
   int iValue;
   int* oValuePtr;
   int& oValueRef;

public:
   int TestClass::ByValMethod1(int Value)
   {
      // Value can be modified
      Value++;

      // iValue can be modified
      iValue = Value;
      iValue += 1;

      // Return value can be modified
      return ++iValue;
   }

   int TestClass::ByValMethod2(const int Value)
   {
      // Value *cannot* be modified
      // Variable is const variable
      Value++;

      // iValue can be modified
      iValue = Value;
      iValue += 1;

      // Return value can be modified
      return ++iValue;
   }

   const int TestClass::ByValMethod3(int Value)
   {
      // Value can be modified
      Value++;

      // iValue can be modified
      iValue = Value;
      iValue += 1;

      // Return value can be modified
      return ++iValue;
   }

   const int TestClass::ByValMethod4(const int Value)
   {
      // Value *cannot* be modified
      // Variable is const variable
      Value++;

      // iValue can be modified
      iValue = Value;
      iValue += 1;

      // Return value can be modified
      return ++iValue;
   }

   const int TestClass::ByValMethod5(const int Value) const
   {
      // Value *cannot* be modified
      // Variable is const variable
      Value++;

      // iValue *cannot* be modified
      // Access through a const object
      iValue = Value;
      iValue += 1;

      // Return value *cannot* be modified
      // Access through a const object
      return ++iValue;
   }

   int& TestClass::ByRefMethod1(int& Value)
   {
      // Value can be modified
      Value++;

      // oValueRef can be modified
      oValueRef = Value;
      oValueRef += 1;

      // Return value can be modified
      return ++oValueRef;
   }

   int& TestClass::ByRefMethod2(const int& Value)
   {
      // Value *cannot* be modified
      // Variable is const variable
      Value++;

      // oValueRef can be modified
      oValueRef = Value;
      oValueRef += 1;

      // Return value can be modified
      return ++oValueRef;
   }

   const int& TestClass::ByRefMethod3(int& Value)
   {
      // Value can be modified
      Value++;

      // oValueRef can be modified
      oValueRef = Value;
      oValueRef += 1;

      // Return value can be modified
      return ++oValueRef;
   }

   const int& TestClass::ByRefMethod4(const int& Value)
   {
      // Value *cannot* be modified
      // Variable is const variable
      Value++;

      // oValueRef can be modified
      oValueRef = Value;
      oValueRef += 1;

      // Return value can be modified
      return ++oValueRef;
   }

   const int& TestClass::ByRefMethod5(const int& Value) const
   {
      // Value *cannot* be modified
      // Variable is const variable
      Value++;

      // oValueRef can be modified
      oValueRef = Value;
      oValueRef += 1;

      // Return value can be modified
      return ++oValueRef;
   }

   int* TestClass::PointerMethod1(int* Value)
   {
      // Value can be modified
      Value++;

      // oValuePtr can be assigned
      oValuePtr = Value;

      // oValuePtr can be modified
      oValuePtr += 1;

      // Return value can be modified
      return ++oValuePtr;
   }

   int* TestClass::PointerMethod2(const int* Value)
   {
      // Value can be modified
      Value++;

      // oValuePtr cannot be assigned
      // const int* to int*
      oValuePtr = Value;

      // oValuePtr can be modified
      oValuePtr += 1;

      // Return value can be modified
      return ++oValuePtr;
   }

   const int* TestClass::PointerMethod3(int* Value)
   {
      // Value can be modified
      Value++;

      // oValuePtr can be assigned
      oValuePtr = Value;

      // iValue can be modified
      oValuePtr += 1;

      // Return value can be modified
      return ++oValuePtr;
   }

   const int* TestClass::PointerMethod4(const int* Value)
   {
      // Value cannot be modified
      Value++;

      // oValuePtr *cannot* be assigned
      // const int* to int*
      oValuePtr = Value;

      // oValuePtr can be modified
      oValuePtr += 1;

      // Return value can be modified
      return ++oValuePtr;
   }

   const int* TestClass::PointerMethod5(const int* Value) const
   {
      // Value can be modified
      ++Value;

      // oValuePtr *cannot* be assigned
      // const int* to int* const
      // Access through a const object
      oValuePtr = Value;

      // oValuePtr *cannot* be modified
      // Access through a const object
      oValuePtr += 1;

      // Return value *cannot* be modified
      return ++oValuePtr;
   }
};

J'espère que ça aide!