const avant paramètre vs const après nom de fonction c++

Question

Quelle est la différence entre un truc comme ça

friend Circle copy(const Circle &);

et quelque chose comme ceci

friend Circle copy(Circle&) const;

Je sais que la constante après la fonction est utilisée pour indiquer au compilateur que cette fonction ne tentera pas de modifier l'objet sur lequel elle est appelée, mais qu'en est-il de l'autre ?

Answer 1

La première forme signifie que le (l'état du) Circle lié à la référence qui est le paramètre de l'objet copy() ne sera pas modifiée par copy() par le biais de cette référence. La référence est une référence à const Il n'est donc pas possible d'invoquer les fonctions membres de l'EPC. Circle à travers cette référence qui ne sont pas eux-mêmes qualifiés de const .

La deuxième forme, par contre, est illégale : seulement fonctions membres peut être const -qualifié (alors que ce que vous déclarez là est un global, friend fonction).

Lorsque const qualifie une fonction membre, la qualification se réfère à l'implicite this argument. En d'autres termes, cette fonction ne sera pas autorisée à modifier l'état de l'objet sur lequel elle est invoquée (l'objet pointé par la fonction implicite this ) - à l'exception de mutable objets, mais c'est une autre histoire.

Pour le dire avec un code :

struct X
{
    void foo() const // <== The implicit "this" pointer is const-qualified!
    {
        _x = 42; // ERROR! The "this" pointer is implicitly const
        _y = 42; // OK (_y is mutable)
    }

    void bar(X& obj) const // <== The implicit "this" pointer is const-qualified!
    {
        obj._x = 42; // OK! obj is a reference to non-const
        _x = 42; // ERROR! The "this" pointer is implicitly const
    }

    void bar(X const& obj) // <== The implicit "this" pointer is NOT const-qualified!
    {
        obj._x = 42; // ERROR! obj is a reference to const
        obj._y = 42; // OK! obj is a reference to const, but _y is mutable
        _x = 42; // OK! The "this" pointer is implicitly non-const
    }

    int _x;
    mutable int _y;
};

Answer 2

Les méthodes des classes C++ ont une fonction implicite this qui vient avant tous les paramètres explicites. Ainsi, une fonction déclarée dans une classe comme celle-ci :

class C {
  void f(int x);

Vous pouvez imaginer que ça ressemble vraiment à ça :

  void f(C* this, int x);

Maintenant, si vous le déclarez de cette façon :

  void f(int x) const;

C'est comme si tu avais écrit ça :

  void f(const C* this, int x);

C'est-à-dire que la queue const fait le this paramètre const, ce qui signifie que vous pouvez invoquer la méthode sur des objets const du type de classe, et que la méthode ne peut pas modifier l'objet sur lequel elle a été invoquée (du moins, pas via les canaux normaux).

Answer 3

---

DISSIPONS TOUTE CONFUSION LIÉE À const

---

const vient de constant signifie que quelque chose n'est pas modifiable mais lisible.

1. si nous qualifions notre variable avec const mot-clé ,on ne peut pas le changer plus tard.
   par exemple
   constint var =25; Une variable constante doit être initialisée lorsqu'elle est déclarée.
   var =50; // gives error

2. si nous qualifions notre variable pointeur avec const après * alors nous ne peut pas changer le pointeur lui-même mais le contenu du pointeur est modifiable* .
   par exemple
   `int `const* ptr = new int;
ptr = new int; //gives error
   // mais
   `ptr=5445; //allowed`

3. si nous qualifions notre variable pointeur avec const avant * alors nous peut changer le pointeur lui-même mais le contenu du pointeur est non modifiable .
   par exemple
   intconst*` ptr = new int(85); //or`
   const*`int ptr = new int(85); ptr = new int; // allowed // mais *ptr=5445; // gives error`

4. le pointeur et le contenu sont tous deux constants
   par exemple
   intconst*constptr = new int(85);
//or
constint *constptr = new int(85);
ptr = new int; // not allowed
*ptr=5445; // not allowed

---

1. Circle copy(const Circle &);
   ici const Circle signifie que la valeur de Circle est seulement lisible, si nous essayons de changer la valeur de Circle dans la fonction, cela donne une erreur.

2. friend Circle copy(Circle&) const;
   Ce type de fonction n'est pas destiné aux variables non membres, il est utilisé pour les classes ou les structures. Ici, toute la fonction est qualifiée avec le mot-clé const, ce qui signifie que nous ne pouvons pas modifier la fonction. objet membre variable . par exemple

   class A{ public :
             int  var;
             void fun1()
                   { var = 50; // allowed
                   } 
             void fun2()const
                      { var=50; //not allowed
                      }
          };

Answer 4

Circle copy(Circle&) const;

rend la fonction const lui-même. Ceci ne peut être utilisé que pour les fonctions membres d'une classe/structure.

Création d'une fonction membre const signifie que

• il ne peut pas appeler toute fonction membre non-const
• il ne peut pas modifier les variables membres.
• il peut être appelé par un const objet( const peuvent uniquement appeler const ). Les objets non constants peuvent également appeler un const fonction.
• Il debe être une fonction membre de la classe ' Cercle '.

Maintenant, considérez la suivante :

Circle copy(const Circle &);

tandis que celui-ci signifie que le paramètre passé ne peut pas être modifié au sein de la fonction. Il peut s'agir ou non d'une fonction membre de la classe.

NOTE : Il est possible de surcharger une fonction de manière à avoir une const et la version non-const de la même fonction.

Answer 5

L'un se réfère au paramètre, l'autre à la fonction.

Circle copy(const Circle &);

Cela signifie que le paramètre passé ne peut pas être modifié dans la fonction.

Circle copy(Circle&) const;

El const La fonction qualifiée est utilisée pour les fonctions membres et signifie que vous ne pouvez pas modifier les données membres de l'objet lui-même. L'exemple que vous avez posté n'a pas de sens.

Lire de droite à gauche

Si nous réécrivons la première fonction comme Circle copy(Circle const&); qui signifie la même chose, il devient clair que la lecture de droite à gauche devient utile. copy est une fonction qui prend un const référence à un Circle et renvoie un Circle par référence.