Exam-Lib: Références et const C++ | Exam-Lib
  1. This site uses cookies. By continuing to use this site, you are agreeing to our use of cookies. Learn More.
Dismiss Notice
Welcome to our Education website, plz like our page facebook to support us. Thank You and wish you good navigation

Références et const C++

abdelouafiNov 25, 2018

    1. abdelouafi

      abdelouafi Administrator Staff Member

      Messages:
      725
      Likes Received:
      14
      Trophy Points:
      38
      Joined
      Sep 13, 2016
      Référence à la valeur const

      Tout comme il est possible de déclarer un pointeur sur une valeur const, il est également possible de déclarer une référence à une valeur const. Ceci est fait en déclarant une référence en utilisant le mot clé const.
      Code:
      const int value = 5;
      const int &ref = value; // ref is a reference to const value
      Les références aux valeurs const sont souvent appelées «références const».

      Initialisation des références aux valeurs const

      Contrairement aux références aux valeurs non constantes, qui ne peuvent être initialisées qu'avec des valeurs l non constantes, les références aux valeurs const peuvent être initialisées avec une valeur l non constante, des valeurs const l et des valeurs r.
      Code:
      int x = 5;
      const int &ref1 = x; // okay, x is a non-const l-value
      const int y = 7;
      const int &ref2 = y; // okay, y is a const l-value
      const int &ref3 = 6; // okay, 6 is an r-value
      Tout comme un pointeur sur une valeur const, une référence à une valeur const peut faire référence à une variable non-const. En cas d'accès via une référence à une valeur const, la valeur est considérée comme constante même si la variable d'origine n'est pas:
      Code:
      int value = 5;
      const int &ref = value; // create const reference to variable value
      value = 6; // okay, value is non-const
      ref = 7; // illegal -- ref is const
      Une référence à un const est souvent appelée une référence const, bien que cela crée une nomenclature incohérente avec des pointeurs.

      Les références aux valeurs-r prolongent la durée de vie de la valeur référencée

      Normalement, les valeurs r ont une portée d'expression, ce qui signifie que les valeurs sont détruites à la fin de l'expression dans laquelle elles sont créées.
      Code:
      std::cout << 2 + 3; // 2 + 3 evaluates to r-value 5, which is destroyed at the end of this statement
      
      Toutefois, lorsqu'une référence à une valeur const est initialisée avec une valeur r, la durée de vie de la valeur r est étendue pour correspondre à la durée de vie de la référence.
      Code:
      int somefcn()
      {
          const int &ref = 2 + 3; // normally the result of 2+3 has expression scope and is destroyed at the end of this statement
          // but because the result is now bound to a reference to a const value...
          std::cout << ref; // we can use it here
      } // and the lifetime of the r-value is extended to here, when the const reference dies
      Références constantes comme paramètres de fonction

      Les références utilisées en tant que paramètres de fonction peuvent également être const. Cela nous permet d’accéder à l’argument sans en faire une copie, tout en garantissant que la fonction ne changera pas la valeur référencée.
      Code:
      // ref is a const reference to the argument passed in, not a copy
      void changeN(const int &ref)
      {
          ref = 6; // not allowed, ref is const
      }
      Les références aux valeurs const sont particulièrement utiles en tant que paramètres de fonction en raison de leur polyvalence. Un paramètre de référence const vous permet de transmettre un argument non constant de valeur l, un argument constant de valeur l, un littéral ou le résultat d'une expression:
      Code:
      #include <iostream>
      void printIt(const int &x)
      {
          std::cout << x;
      }
      int main()
      {
          int a = 1;
          printIt(a); // non-const l-value
          const int b = 2;
          printIt(b); // const l-value
          printIt(3); // literal r-value
          printIt(2+b); // expression r-value
          return 0;
      }
      Les impressions ci-dessus
      1234

      Pour éviter de faire des copies inutiles et potentiellement coûteuses, les variables qui ne sont ni des pointeurs ni des types de données fondamentaux (int, double, etc.) doivent généralement être passées par référence (const). Les types de données fondamentaux doivent être passés par valeur, sauf si la fonction doit les modifier.

      Règle: Transmettez des variables de type de données non-pointeur et non fondamental (telles que structs) par référence (const).
       
      Loading...

      Merci de partager ce post sur facebook

    2. Merci d'aimer notre facebook page

Share This Page