C ++11 auto: et si une référence constante était obtenue?

Question

Veuillez prendre un coup d'oeil au code simple suivant:

class Foo
{
public:
  Foo(){}
  ~Foo(){}

  Foo(const Foo&){}
  Foo& operator=(const Foo&) { return *this; }
};

static Foo g_temp;
const Foo& GetFoo() { return g_temp; }

J'ai essayé d'utiliser auto comme ceci:

auto my_foo = GetFoo();

J'attendais qu' my_foo sera une constante référence à l' Foo, qui est le type de retour de la fonction. Cependant, le type d' auto est Foo, pas de la référence. En outre, my_foo est créé en copiant g_temp. Ce comportement n'est pas évident pour moi.

Afin d'obtenir la référence à l' Foo, j'ai besoin de l'écrire comme ceci:

const auto& my_foo2 = GetFoo();
      auto& my_foo3 = GetFoo();

Question: Pourquoi est - auto en déduire le type de retour d' GetFoo comme un objet, pas une référence?

Answer 1

Lire cet article: Apparaissant et Disparaissant consts en C++

---

Type de déduction automatique de variables en C++0x est essentiellement la même que pour les paramètres du modèle. (Autant que je sache, la seule différence entre les deux est que le type de variables automatique peut être déduite à partir de initialisation des listes, alors que les types des paramètres du modèle peuvent ne pas l'être.) Chacune des déclarations suivantes, par conséquent, déclarer des variables de type int (jamais const int):

auto a1 = i;
auto a2 = ci;
auto a3 = *pci;
auto a4 = pcs->i;

Durant la déduction des paramètres du modèle et les variables automatique, seulement niveau supérieur consts sont supprimés. Étant donné un modèle de fonction prenant un pointeur ou une référence de paramètre, le constness de tout ce qui est pointu ou visé est retenu:

template<typename T>
void f(T& p);

int i;
const int ci = 0;
const int *pci = &i;

f(i);               // as before, calls f<int>, i.e., T is int
f(ci);              // now calls f<const int>, i.e., T is const int
f(*pci);            // also calls f<const int>, i.e., T is const int

Ce comportement est de vieilles nouvelles, puisqu'elle s'applique à la fois au C++98 et C++03. Le correspondant comportement de l'auto variables est, bien sûr, nouvelle C++0x:

auto& a1 = i;       // a1 is of type int&
auto& a2 = ci;      // a2 is of type const int&
auto& a3 = *pci;    // a3 is also of type const int&
auto& a4 = pcs->i;  // a4 is of type const int&, too

---

Puisque vous pouvez conserver le cv-qualifier si le type est une référence ou un pointeur, vous pouvez le faire:

auto& my_foo2 = GetFoo();

Au lieu d'avoir à le définir en tant que const (en va de même pour l' volatile).

Edit: et pourquoi auto en déduit le type de retour d' GetFoo() comme valeur au lieu d'une référence (ce qui a été votre principale question, désolé), pensez à ceci:

const Foo my_foo = GetFoo();

Le ci-dessus va créer une copie, depuis my_foo est une valeur. Si auto étaient de retour une lvalue de référence, le ci-dessus ne serait pas possible.