Czy powinienem używać nowej funkcji „auto” C ++ 11, szczególnie w pętlach?

Jakie są zalety / wady używania autosłowa kluczowego, szczególnie w przypadku pętli?

for(std::vector<T>::iterator it = x.begin(); it != x.end(); it++ )
{
   it->something();
}

for(std::map<T>::iterator it = x.begin(); it != x.end(); it++ )
{
   it->second->something();
}

for(auto it = x.begin(); it != x.end(); it++ )
{
   it->??
}

Wygląda na to, jeśli nie wiem, czy masz iterator na mapie lub wektor ty nie wiesz, czy użyć firstlub secondczy tylko bezpośrednio właściwości dostępu obiektu, nie?

To przypomina mi debatę C # na temat tego, czy użyć słowa kluczowego var. Mam wrażenie, że do tej pory mam wrażenie, że w świecie C ++ ludzie są gotowi na przyjęcie autosłowa kluczowego bez większego wysiłku niż varw świecie C #. Moim pierwszym instynktem jest to, że lubię znać typ zmiennej, aby wiedzieć, jakie operacje mogę na niej wykonać.

Motywacje w C ++ są bardziej ekstremalne, ponieważ typy mogą stać się znacznie bardziej skomplikowane i złożone niż typy C # z powodu metaprogramowania i innych rzeczy. autojest szybszy w pisaniu i czytaniu oraz bardziej elastyczny / łatwy w utrzymaniu niż typ jawny. Mam na myśli, czy chcesz zacząć pisać?

boost::multi_map<NodeType, indexed_by<ordered_unique<identity<NodeType>>, hashed_non_unique<identity<NodeType>, custom_hasher>>::iterator_type<0> it

To nie jest nawet pełny typ. Opuściłem kilka argumentów szablonu.

W twoim przykładzie:

for(auto it = x.begin(); it != x.end(); i++)
{
  it->??
}

musi być deklaracja xwidoczna. Dlatego rodzaj itpowinien być oczywisty. Jeśli typ xnie jest oczywisty, wówczas metoda jest za długa lub klasa jest za duża.

Sprzeciw ! Załadowane pytanie.

Czy możesz mi wyjaśnić, dlaczego zawiera trzeci kod ??, a pierwszy i drugi nie? W trosce o sprawiedliwość kod musi mieć następujące brzmienie:

for(std::vector<T>::iterator it = x.begin(); it != x.end(); i++)
{
   it->???
}

for(std::map<T>::iterator it = x.begin(); it != x.end(); i++)
{
   it->second->???
}

Tam. Ten sam problem, nawet jeśli nie korzystałeś auto.

I we wszystkich przypadkach odpowiedź jest taka sama: kontekst ma znaczenie . Nie możesz w sposób znaczący mówić o kawałku kodu w izolacji. Nawet jeśli nie używałeś szablonów, ale jakiś konkretny typ, problem przesunąłby to tylko gdzie indziej, ponieważ czytelnik twojego kodu musiałby wiedzieć o deklaracji tego typu.

Jeśli użycie autow takich sytuacjach spowoduje, że Twój kod będzie nieczytelny, powinieneś traktować to jako znak ostrzegawczy, że coś jest nie tak z projektem kodu. Oczywiście zdarzają się przypadki, w których istotne są szczegóły niskiego poziomu (na przykład w przypadku operacji bitowych lub starszego interfejsu API), w których wyraźny typ może poprawić czytelność. Ale ogólnie - nie.

Jeśli chodzi o var(ponieważ wyraźnie o tym wspomniałeś), istnieje również szeroki konsensus w społeczności C # w zakresie używania var. Argumenty przeciwko jego stosowaniu są zwykle oparte na błędach .

ZAWODOWIEC

Twój kod :

for(std::vector<T>::iterator it = x.begin(); it != x.end(); i++)

nie będzie się kompilować z powodu nazwy zależnej od szablonu.

Oto poprawna składnia:

for( typename std::vector<T>::iterator it = x.begin(); it != x.end(); i++)

Teraz spójrz, jak długo trwa deklaracja typu. To wyjaśnia, dlaczego autosłowo kluczowe zostało wprowadzone. To:

for( auto it = x.begin(); it != x.end(); i++)

jest bardziej zwięzły. To jest zawodowiec.

KON

Musisz być trochę ostrożny. Za pomocą słowa kluczowego autootrzymujesz zadeklarowany typ.

Na przykład :

std::vector< int > v{ 1, 2, 3, 4 };
for ( auto it : v )
{
  ++ it;   // ops modifying copies of vector's elements
}

vs

std::vector< int > v{ 1, 2, 3, 4 };
for ( auto & it : v )   // mind the reference
{
  ++ it;   // ok, vector's elements modified
}

Podsumowując: tak, powinieneś to zrobić, ale nie nadużywaj go. Niektórzy ludzie używają go zbyt często i wszędzie ustawiają auto, jak w następnym przykładzie:

auto i = 0;

vs

int i = 0;

Tak, powinieneś! autonie usuwa tego typu; nawet jeśli „nie wiesz”, co to x.begin()jest, kompilator wie i zgłosi błąd, jeśli spróbujesz nieprawidłowo użyć tego typu. Ponadto emulacja za mappomocą a nie jest niczym niezwykłym vector<pair<Key,Value>>, więc użycie kodu autobędzie działać dla obu reprezentacji słownikowych.

Tak, powinieneś użyć autojako domyślnej reguły. Ma surowe zalety w porównaniu z jawnym określaniem typu:

• Nie powoduje, że wpisujesz rzeczy, o których kompilator jest już świadomy.
• Sprawia, że ​​typ zmiennych „śledzi” każdą zmianę typów wartości zwracanych.
• Dzięki temu zapobiega cichemu wprowadzaniu niejawnych konwersji i krojenia w inicjalizację zmiennych lokalnych.
• Eliminuje to potrzebę pewnych jawnych obliczeń typu w szablonach.
• Eliminuje to konieczność nazywania typów zwrotów długimi nazwami. (te, które kopiujesz i wklejasz z diagnostyki kompilatora)

Tutaj masz wybór. Są też przypadki, w których nie masz wyboru:

• Pozwala na deklarację zmiennych typów nieprzekraczalnych, takich jak typ lambda.

Pod warunkiem, że dokładnie wiesz, co autorobi, nie ma żadnych wad.