Должен ли я использовать новую функцию auto в C ++ 11, особенно в циклах?

Каковы плюсы / минусы использования autoключевого слова, особенно в циклах for?

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->??
}

Похоже, если вы не знаете, есть ли у вас итератор для карты или вектора, вы не знаете, использовать firstли secondили просто напрямую обращаться к свойствам объекта, нет?

Это напоминает мне спор о том, стоит ли использовать ключевое слово в C # var. У меня сложилось впечатление, что в мире C ++ люди готовы принять autoключевое слово с меньшими усилиями, чем varв мире C #. Для меня мой первый инстинкт заключается в том, что мне нравится знать тип переменной, чтобы я мог знать, какие операции я могу ожидать над ней.

Мотивации в C ++ более экстремальны, поскольку типы могут стать значительно более запутанными и сложными, чем типы C #, из-за метапрограммирования и других вещей. autoбыстрее писать и читать и более гибкий / обслуживаемый, чем явный тип. Я имею в виду, ты хочешь начать печатать

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

Это даже не полный тип. Я пропустил пару аргументов шаблона.

В вашем примере:

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

должна быть декларация для xвидимого. Поэтому тип itдолжен быть очевидным. Если тип xнеочевиден, то метод слишком длинный или класс слишком большой.

Возражение ! Загруженный вопрос.

Можете ли вы объяснить мне, почему третий код содержит ??, а первый и второй нет? Справедливости ради, ваш код должен выглядеть следующим образом:

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->???
}

Там. Та же проблема, даже если вы не использовали auto.

И во всех случаях ответ один и тот же: контекст имеет значение . Вы не можете осмысленно говорить о куске кода изолированно. Даже если бы вы не использовали шаблоны, а использовали какой-то конкретный тип, это только переместило бы проблему куда-нибудь еще, поскольку читатель вашего кода должен был бы знать об объявлении указанного типа.

Если использование autoв таких ситуациях делает ваш код нечитаемым, вы должны воспринимать это как предупреждение о том, что с вашим дизайном кода что-то не так. Конечно, есть случаи, когда низкоуровневые детали имеют значение (например, при работе с битовыми операциями или устаревшим API), когда явный тип может способствовать удобочитаемости. Но в целом - нет.

Что касается var(поскольку вы прямо упомянули об этом), в сообществе C # также существует широкий консенсус в отношении использования var. Аргументы против его использования обычно основаны на заблуждениях .

PRO

Ваш код :

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

не собирается компилироваться из-за зависимого от шаблона имени.

Это правильный синтаксис:

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

Посмотрите, как долго объявление типа. Это говорит о том, почему autoбыло введено ключевое слово. Эта :

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

является более кратким. Итак, это профессионал.

ПРОТИВ

Вы должны быть немного осторожны. С ключевым словом autoвы получите тип, который вы объявили.

Например :

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

против

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

В заключение: да, вы должны это, но не злоупотреблять этим. Некоторые люди склонны использовать его слишком часто, и везде ставят auto, как в следующем примере:

auto i = 0;

против

int i = 0;

Да, ты должен! autoне стирает тип; даже если вы «не знаете», что x.begin()такое, компилятор знает и сообщит об ошибке, если вы попытаетесь использовать тип неправильно. Кроме того, нет ничего необычного в том, чтобы эмулировать mapс помощью a vector<pair<Key,Value>>, поэтому использование кода autoбудет работать для обоих представлений в словаре.

Да, вы должны использовать autoв качестве правила по умолчанию. Он имеет ряд преимуществ по сравнению с явным указанием типа:

• Это не заставляет вас печатать то, о чем уже знает компилятор.
• Это заставляет тип переменных «следовать за» любым изменением типов возвращаемых значений.
• Это предотвращает тихое введение неявных преобразований и секционирование при инициализации локальной переменной.
• Это устраняет необходимость некоторых явных вычислений типов в шаблонах.
• Это устраняет необходимость именования возвращаемых типов с длинными именами. (те, которые вы копируете из диагностики компилятора)

Здесь у вас есть выбор. Есть также случаи, когда у вас нет выбора:

• Это позволяет объявлять переменные невыбираемых типов, таких как лямбда-типы.

При условии, что вы точно знаете, что делаете auto, у него нет недостатков.