Quelle est la bonne manière de l'aide de C++11 de gamme pour?

Commençons la différenciation entre observation les éléments dans le continer
vs modifiant en place.

En observant les éléments

Prenons un exemple simple:

vector<int> v = {1, 3, 5, 7, 9};

for (auto x : v)
    cout << x << ' ';

Le code ci-dessus imprime les éléments (ints) dans le vector:

1 3 5 7 9

Considérons maintenant un autre cas, dans lequel les éléments du vecteur sont pas seulement de simples entiers,
mais des cas de plus en plus complexes, de la classe, avec le custom constructeur de copie, etc.

//A sample test class, with custom copy semantics.
class X
{
public:
    X() 
        : m_data(0) 
    {}

    X(int data)
        : m_data(data)
    {}

    ~X() 
    {}

    X(const X& other) 
        : m_data(other.m_data)
    { cout << "X copy ctor.\n"; }

    X& operator=(const X& other)
    {
        m_data = other.m_data;       
        cout << "X copy assign.\n";
        return *this;
    }

    int Get() const
    {
        return m_data;
    }

private:
    int m_data;
};

ostream& operator<<(ostream& os, const X& x)
{
    os << x.Get();
    return os;
}

Si nous utilisons la for (auto x : v) {...} syntaxe avec cette nouvelle classe:

vector<X> v = {1, 3, 5, 7, 9};

cout << "\nElements:\n";
for (auto x : v)
{
    cout << x << ' ';
}

la sortie est quelque chose comme:

[... copy constructor calls for vector<X> initialization ...]

Elements:
X copy ctor.
1 X copy ctor.
3 X copy ctor.
5 X copy ctor.
7 X copy ctor.
9

Comme il peut être lu à partir de la sortie, constructeur de copie les appels sont effectués au cours de
gamme pour les itérations de boucle.

C'est parce que nous sommes capture les éléments du conteneur en valeur
(le auto x partie dans for (auto x : v)).

C'est inefficace code, par exemple, si ces éléments sont des instances de std::string,
tas les allocations de mémoire qui peut être fait, avec des déplacements coûteux pour le gestionnaire de mémoire, etc.
C'est inutile si nous voulons juste observer les éléments dans un conteneur.

Donc, une meilleure syntaxe est disponible: capture par const référence, c'est à dire const auto&:

vector<X> v = {1, 3, 5, 7, 9};

cout << "\nElements:\n";
for (const auto& x : v)
{ 
    cout << x << ' ';
}

Maintenant la sortie est:

 [... copy constructor calls for vector<X> initialization ...]

Elements:
1 3 5 7 9

Sans aucune fausse (et potentiellement coûteux) constructeur de copie d'appel.

Donc, quand observation éléments dans un conteneur (par exemple, pour un accès en lecture seule),
la syntaxe suivante est très bien pour de simples pas cher à copier types, comme int, double, etc.:

for (auto elem : container) 

D'autre, la capture par const de référence est le meilleur dans le cas général,
pour éviter d'inutiles (et potentiellement coûteux) constructeur de copie d'appels:

for (const auto& elem : container) 

Modifier les éléments dans le conteneur

Si nous voulons modifier les éléments dans un conteneur à l'aide de gamme à base de for,
le ci-dessus for (auto elem : container) et for (const auto& elem : container)
les syntaxes sont mauvais.

En fait, dans le premier cas, elem magasins un copie de l'original
élément, de sorte que les modifications apportées à celui-ci sont juste perdus et ne sont pas stockées de façon persistante
dans le conteneur, par exemple:

vector<int> v = {1, 3, 5, 7, 9};
for (auto x : v)  //<-- capture by value (copy)
    x *= 10;      //<-- a local temporary copy ("x") is modified,
                  //    *not* the original vector element.

for (auto x : v)
    cout << x << ' ';

Le résultat est juste la séquence initiale:

1 3 5 7 9

Au lieu de cela, une tentative de utilisant for (const auto& x : v) juste ne peut pas compiler.

g++ renvoie un message d'erreur à quelque chose comme ceci:

TestRangeFor.cpp:138:11: error: assignment of read-only reference 'x'
          x *= 10;
            ^

La bonne approche dans ce cas est la capture par des non-const référence:

vector<int> v = {1, 3, 5, 7, 9};
for (auto& x : v)
    x *= 10;

for (auto x : v)
    cout << x << ' ';

La sortie est (comme prévu):

10 30 50 70 90

Ce for (auto& elem : container) syntaxe fonctionne aussi pour les types plus complexes,
par exemple, en considérant un vector<string>:

vector<string> v = {"Bob", "Jeff", "Connie"};

//Modify elements in place: use "auto &"
for (auto& x : v)
    x = "Hi " + x + "!";

//Output elements (*observing* --> use "const auto&")
for (const auto& x : v)
    cout << x << ' ';

la sortie est:

Hi Bob! Hi Jeff! Hi Connie!

Le cas particulier de proxy itérateurs

Supposons que nous avons une vector<bool>, et nous voulons inverser la logique booléenne état
de ses éléments, en utilisant la syntaxe ci-dessus:

vector<bool> v = {true, false, false, true};
for (auto& x : v)
    x = !x;

Le code ci-dessus ne peut pas compiler.

g++ renvoie un message d'erreur semblable à ceci:

TestRangeFor.cpp:168:20: error: invalid initialization of non-const reference of
 type 'std::_Bit_reference&' from an rvalue of type 'std::_Bit_iterator::referen
ce {aka std::_Bit_reference}'
     for (auto& x : v)
                    ^

Le problème est que std::vector modèle est spécialisé pour bool, avec un
la mise en œuvre que packs la bools pour optimiser l'espace (chaque valeur de type boolean est
stockées dans un bit, huit "boolean" bits dans un octet).

À cause de cela (puisqu'il n'est pas possible de retourner une référence à un seul bit),
vector<bool> utilise ce qu'on appelle "proxy itérateur" modèle.
Un "proxy itérateur" est un itérateur qui, lorsque déréférencé, ne pas le rendement d'une
ordinaire bool &, mais au lieu de cela renvoie (en valeur) d'un objet temporaire,
qui est un spécialisation sur Wikipedia">de la classe proxy convertibles à boolean.
(Voir aussi ::la référence ne renvoie pas de référence à bool?">cette question et les réponses connexes ici sur StackOverflow.)

À modifier les éléments en place de vector<bool>, un nouveau type de syntaxe (à l'aide de auto&&)
doit être utilisé:

for (auto&& x : v)
    x = !x;

Le code suivant fonctionne:

vector<bool> v = {true, false, false, true};

//Invert boolean status
for (auto&& x : v)  //<-- note use of "auto&&" for proxy iterators
    x = !x;

//Print new element values
cout << boolalpha;        
for (const auto& x : v)
    cout << x << ' ';

et sorties:

false true true false

Noter que le for (auto&& elem : container) syntaxe fonctionne également dans l'autre cas
d'ordinaire (sans proxy) itérateurs (par exemple, pour un vector<int> ou un vector<string>).

(Comme une note de côté, cette "observation" de la syntaxe de for (const auto& elem : container) fonctionne très bien aussi pour le proxy itérateur cas.)

Résumé

La discussion ci-dessus peuvent être résumées dans le guide-lignes:

1. Pour observation les éléments, utilisez la syntaxe suivante:

   for (const auto& elem : container)    //capture by const reference

   • Si les objets sont à bas prix pour copier (comme ints, doubles, etc.),
     il est possible d'utiliser une forme légèrement simplifiée:

     for (auto elem : container)    //capture by value

                 

2. Pour modifiant les éléments en place, utilisation:

   for (auto& elem : container)    //capture by (non-const) reference

   • Si le conteneur utilise "proxy itérateurs" (comme std::vector<bool>), utilisation:

     for (auto&& elem : container)    //capture by &&

Bien sûr, si il ya un besoin de faire un copie locale de l'élément à l'intérieur du corps de la boucle, la capture de en valeur (for (auto elem : container)) est un bon choix.

---

Notes supplémentaires sur les génériques de code

Dans code générique, puisque nous ne pouvons pas faire des hypothèses sur le type générique T être pas cher, à copier, à observation mode, il est sûr de toujours utiliser for (const auto& elem : container).

(Ce ne sera pas déclencher potentiellement coûteux des copies inutiles, fonctionne très bien aussi pour pas cher-pour-copie des types comme int, et aussi pour les récipients à l'aide de proxy-les itérateurs, comme std::vector<bool>.)

En outre, dans modifiant mode, si nous voulons code générique de travailler également en cas de procuration-les itérateurs, la meilleure option est for (auto&& elem : container).

(Cela fonctionne très bien aussi pour les conteneurs à l'aide d'ordinaire non-proxy-les itérateurs, comme std::vector<int> ou std::vector<string>.)

Donc, dans code générique, les lignes directrices suivantes peuvent être fournies:

1. Pour observation les éléments, utilisation:

   for (const auto& elem : container)

2. Pour modifiant les éléments en place, utilisation:

   for (auto&& elem : container)

Le bon moyen est toujours

for(auto&& elem : container)

Cela permettra de garantir la préservation de l'ensemble de la sémantique.