Jaki jest właściwy sposób używania opartego na zakresie C ++ 11 for?

Jakiej składni należy użyć? for (auto elem : container)lub for (auto& elem : container)lub for (const auto& elem : container)? A może jakiś inny?

Zacznijmy od rozróżnienia między obserwowaniem elementów w pojemniku a modyfikowaniem ich na miejscu.

Obserwować elementy

Rozważmy prosty przykład:

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

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

Powyższy kod drukuje elementy intw vector:

1 3 5 7 9

Rozważmy teraz inny przypadek, w którym elementy wektorowe nie są zwykłymi liczbami całkowitymi, ale instancjami bardziej złożonej klasy z niestandardowym konstruktorem kopii itp.

// 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;
}

Jeśli użyjemy powyższej for (auto x : v) {...}składni z nową klasą:

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

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

wynik jest podobny do:

[... 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

Jak można odczytać z wyjścia, wywołania konstruktora kopiowania są wykonywane podczas iteracji pętli na podstawie zakresu.
Wynika to z tego, że przechwytujemy elementy z kontenera według wartości ( auto xczęść wfor (auto x : v) ).

Jest to nieefektywny kod, np. Jeśli te elementy są instancjami std::string, można dokonać alokacji pamięci sterty, kosztownych podróży do menedżera pamięci itp. Jest to bezużyteczne, jeśli chcemy tylko obserwować elementy w kontenerze.

Dostępna jest więc lepsza składnia: przechwytywanie przez constreferencję , tj . const auto&:

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

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

Teraz dane wyjściowe to:

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

Elements:
1 3 5 7 9

Bez żadnego fałszywego (i potencjalnie kosztownego) wywołania konstruktora kopiowania.

Tak więc, gdy obserwując elementy w pojemniku (czyli dla dostępem tylko do odczytu), następujące składnia jest w porządku dla prostych tani do imitowania typów, jak int, doubleitp .:

for (auto elem : container) 

W przeciwnym razie przechwytywanie przez constodniesienie jest lepsze w ogólnym przypadku , aby uniknąć niepotrzebnych (i potencjalnie drogich) wywołań konstruktora kopiowania:

for (const auto& elem : container) 

Modyfikacja elementów w kontenerze

Jeśli chcemy zmodyfikować elementy w kontenerze za pomocą zakresu for, powyższe for (auto elem : container)i for (const auto& elem : container) składnie są niepoprawne.

W rzeczywistości w pierwszym przypadku elemprzechowuje kopię oryginalnego elementu, więc modyfikacje dokonane w nim są po prostu tracone i nie są trwale przechowywane w kontenerze, np .:

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 << ' ';

Dane wyjściowe to tylko sekwencja początkowa:

1 3 5 7 9

Zamiast tego próba użycia for (const auto& x : v)po prostu się nie kompiluje.

g ++ wyświetla komunikat o błędzie podobny do tego:

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

Prawidłowe podejście w tym przypadku polega na uchwyceniu przez brak constodniesienia:

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

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

Dane wyjściowe są (zgodnie z oczekiwaniami):

10 30 50 70 90

Ta for (auto& elem : container)składnia działa również w przypadku bardziej złożonych typów, np. Biorąc pod uwagę 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 << ' ';

dane wyjściowe to:

Hi Bob! Hi Jeff! Hi Connie!

Szczególny przypadek iteratorów proxy

Załóżmy, że mamy vector<bool>, i chcemy odwrócić logiczny stan logiczny jego elementów, używając powyższej składni:

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

Powyższy kod się nie kompiluje.

g ++ wyświetla komunikat o błędzie podobny do tego:

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)
                    ^

Problemem jest to, że std::vectorszablon wyspecjalizowane dla boolz implementacji, że pakiety z boolS do miejsca Optymalizacja (każda wartość logiczna jest przechowywany w jednym kawałku, ośmiu „wartość logiczna” bitów bajtu).

Z tego powodu (ponieważ nie można zwrócić referencji do jednego bitu) vector<bool>używa tak zwanego wzorca „iteratora proxy” . „Iterator proxy” to iterator, który po dereferencji nie daje zwykłego bool &, ale zwraca (według wartości) obiekt tymczasowy , do którego można przekształcić klasę proxybool . (Zobacz także to pytanie i powiązane odpowiedzi tutaj na StackOverflow.)

Aby zmodyfikować w miejscu elementy vector<bool>, należy użyć nowego rodzaju składni (using auto&&):

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

Poniższy kod działa poprawnie:

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 << ' ';

i wyniki:

false true true false

Zauważ, że for (auto&& elem : container)składnia działa również w innych przypadkach zwykłych iteratorów (niebędących proxy) (np. Dla a vector<int>lub avector<string> ).

(Na marginesie, wspomniana wyżej „obserwująca” składnia for (const auto& elem : container)działa dobrze również w przypadku iteratora proxy).

Podsumowanie

Powyższą dyskusję można streścić w następujących wytycznych:

1. Aby obserwować elementy, użyj następującej składni:

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

   • Jeśli obiekty są tanie do skopiowania (takie jak ints, doubles itp.), Można użyć nieco uproszczonej formy:

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

2. Aby zmodyfikować elementy na miejscu, użyj:

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

   • Jeśli kontener używa „iteratorów proxy” (jak std::vector<bool>), użyj:

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

Oczywiście, jeśli istnieje potrzeba wykonania lokalnej kopii elementu w ciele pętli, dobrym rozwiązaniem jest przechwycenie za pomocą value ( for (auto elem : container)).

Dodatkowe uwagi na temat kodu ogólnego

W ogólnym kodzie , ponieważ nie możemy zakładać, że typ ogólny Tjest tani do kopiowania, w trybie obserwacji zawsze można bezpiecznie używać for (const auto& elem : container).
(Nie uruchomi to potencjalnie kosztownych, bezużytecznych kopii, będzie działać dobrze również w przypadku typów tanich do kopiowania, takich jak int, a także w przypadku kontenerów korzystających z iteratorów proxy itp std::vector<bool>.)

Co więcej, w trybie modyfikacji , jeśli chcemy, aby kod ogólny działał również w przypadku iteratorów proxy, najlepszą opcją jest for (auto&& elem : container).
(Będzie to działać dobrze również w przypadku kontenerów używających zwykłych iteratorów innych niż proxy, takich jak std::vector<int>lubstd::vector<string> .)

Zatem w kodzie ogólnym można podać następujące wytyczne:

1. Do obserwacji elementów użyj:

   for (const auto& elem : container)

2. Aby zmodyfikować elementy na miejscu, użyj:

   for (auto&& elem : container)

Nie ma prawidłowego sposobu użycia for (auto elem : container), lub for (auto& elem : container)lub for (const auto& elem : container). Po prostu wyrażasz, co chcesz.

Pozwól mi rozwinąć tę kwestię. Przejdźmy się.

for (auto elem : container) ...

Ten jest cukrem syntaktycznym dla:

for(auto it = container.begin(); it != container.end(); ++it) {

    // Observe that this is a copy by value.
    auto elem = *it;

}

Możesz użyć tego, jeśli twój kontener zawiera elementy, których kopiowanie jest tanie.

for (auto& elem : container) ...

Ten jest cukrem syntaktycznym dla:

for(auto it = container.begin(); it != container.end(); ++it) {

    // Now you're directly modifying the elements
    // because elem is an lvalue reference
    auto& elem = *it;

}

Użyj tego, jeśli chcesz na przykład pisać bezpośrednio do elementów w kontenerze.

for (const auto& elem : container) ...

Ten jest cukrem syntaktycznym dla:

for(auto it = container.begin(); it != container.end(); ++it) {

    // You just want to read stuff, no modification
    const auto& elem = *it;

}

Jak mówi komentarz, tylko do czytania. I o to chodzi, wszystko jest „prawidłowe”, gdy jest właściwie używane.

Prawidłowe środki są zawsze

for(auto&& elem : container)

Zagwarantuje to zachowanie całej semantyki.

Podczas gdy początkową motywacją dla pętli zasięgu może być łatwość iteracji po elementach kontenera, składnia jest na tyle ogólna, że ​​jest użyteczna nawet dla obiektów, które nie są czysto kontenerami.

Wymaganiem składniowym dla pętli for jest to, że range_expressionobsługuje begin()i end()jako obie funkcje - albo jako funkcje składowe typu, którego ocenia, albo jako funkcje nie będące członkami, które przyjmują instancję typu.

Jako wymyślony przykład można wygenerować zakres liczb i iterować po nim, używając następującej klasy.

struct Range
{
   struct Iterator
   {
      Iterator(int v, int s) : val(v), step(s) {}

      int operator*() const
      {
         return val;
      }

      Iterator& operator++()
      {
         val += step;
         return *this;
      }

      bool operator!=(Iterator const& rhs) const
      {
         return (this->val < rhs.val);
      }

      int val;
      int step;
   };

   Range(int l, int h, int s=1) : low(l), high(h), step(s) {}

   Iterator begin() const
   {
      return Iterator(low, step);
   }

   Iterator end() const
   {
      return Iterator(high, 1);
   }

   int low, high, step;
}; 

Dzięki następującej mainfunkcji

#include <iostream>

int main()
{
   Range r1(1, 10);
   for ( auto item : r1 )
   {
      std::cout << item << " ";
   }
   std::cout << std::endl;

   Range r2(1, 20, 2);
   for ( auto item : r2 )
   {
      std::cout << item << " ";
   }
   std::cout << std::endl;

   Range r3(1, 20, 3);
   for ( auto item : r3 )
   {
      std::cout << item << " ";
   }
   std::cout << std::endl;
}

otrzymamy następujące dane wyjściowe.

1 2 3 4 5 6 7 8 9 
1 3 5 7 9 11 13 15 17 19 
1 4 7 10 13 16 19