Есть ли причина использовать ключевое слово auto в C ++ 03?

Обратите внимание, что этот вопрос был первоначально опубликован в 2009 году, до ратификации C ++ 11 и до того, как значение autoключевого слова было радикально изменено. Предоставленные ответы относятся только к значению C ++ 03 auto, которое является указанным классом хранения, а не к значению C ++ 11, autoкоторое является автоматическим выводом типа. Если вам нужен совет о том, когда использовать C ++ 11 auto, этот вопрос не имеет отношения к этому вопросу.

Долгое время я думал, что нет причин использовать staticключевое слово в C, потому что переменные, объявленные вне области видимости блока, были неявно глобальными. Затем я обнаружил, что объявление переменной в staticпределах области видимости блока даст ей постоянную продолжительность, а объявление ее вне области видимости блока (в области программы) даст ей область видимости файла (доступ к которой можно получить только в этом модуле компиляции).

Таким образом, у меня остается только одно ключевое слово, которое я (возможно) еще не полностью понимаю: autoключевое слово. Есть ли у него какое-то другое значение, кроме «локальная переменная»? Что-нибудь, что он делает, что явно не сделано для вас, где бы вы ни захотели его использовать? Как autoпеременная ведет себя в области программы? Что насчет static autoпеременной в области видимости файла? У этого ключевого слова есть какая-либо цель, кроме как просто существовать для полноты ?

autoкласс хранения спецификатор static, registerи externтоже. В объявлении можно использовать только один из этих четырех.

Локальные переменные (без static) имеют автоматическую продолжительность хранения, что означает, что они живут с начала своего определения до конца своего блока. Ставить перед ними auto излишне, поскольку в любом случае это значение по умолчанию.

Я не знаю причин использовать его в C ++. В старых версиях C, имеющих неявное правило int, вы могли использовать его для объявления переменной, например:

int main(void) { auto i = 1; }

Чтобы сделать его допустимым синтаксисом или устранить неоднозначность из выражения присваивания в случае, если это iвходит в область действия. Но в C ++ это все равно не работает (нужно указать тип). Как ни странно, стандарт C ++ пишет:

Объект, объявленный без спецификатора класса хранения в области блока или объявленный как параметр функции, по умолчанию имеет автоматическую продолжительность хранения. [Примечание: следовательно, автоматический спецификатор почти всегда избыточен и не часто используется; одно использование auto состоит в том, чтобы явно отличить оператор-объявление от оператора-выражения (6.8). - конец примечания]

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

int(a);

С новым смыслом появления autoC ++ 0x я бы не рекомендовал использовать его со значением C ++ 03 в коде.

В C ++ 11 это autoимеет новое значение: оно позволяет автоматически определять тип переменной.

Почему это вообще полезно? Рассмотрим базовый пример:

std::list<int> a;
// fill in a
for (auto it = a.begin(); it != a.end(); ++it) {
  // Do stuff here
}

autoЕсть создает итератор типа std::list<int>::iterator.

Это может значительно упростить чтение очень сложного кода.

Другой пример:

int x, y;
auto f = [&]{ x += y; };
f();
f();

Там autoвыведен тип, необходимый для хранения лямбда-выражения в переменной. Википедия хорошо освещает эту тему.

Ключевое слово auto на данный момент не имеет смысла. Вы совершенно правы, что он просто повторно устанавливает класс хранения по умолчанию для локальной переменной, что является действительно полезной альтернативой static.

В C ++ 0x он имеет совершенно новое значение . Это дает вам некоторое представление о том, насколько это было бесполезно!

GCC имеет специальное использование autoдля вложенных функций - см. Здесь .

Если у вас есть вложенная функция, которую вы хотите вызвать до ее определения, вам нужно объявить ее с помощью auto.

"auto" якобы указывает компилятору самому решить, куда поместить переменную (память или регистр). Его аналог - «регистр», который якобы указывает компилятору попытаться сохранить его в регистре. Современные компиляторы игнорируют и то, и другое, так что вы должны тоже.

Я использую это ключевое слово для явного документирования, когда для функции критично размещение переменной в стеке для стековых процессоров. Эта функция может потребоваться при изменении стека перед возвратом из функции (или подпрограммы обслуживания прерывания). В этом случае заявляю:

auto unsigned int auiStack[1];   //variable must be on stack

И затем я обращаюсь за пределами переменной:

#define OFFSET_TO_RETURN_ADDRESS 8     //depends on compiler operation and current automatics
auiStack[OFFSET_TO_RETURN_ADDRESS] = alternate_return_address;

Таким образом, autoключевое слово помогает документировать намерение.

Согласно Страуструпу, в «Языке программирования C» (4-е издание, охватывающее C 11) использование слова «auto» имеет следующие основные причины (раздел 2.2.2) (слова Страуструпа цитируются):

1)

Определение находится в большом объеме, и мы хотим, чтобы тип был четко видим для читателей нашего кода.

С помощью «auto» и его необходимого инициализатора мы можем сразу узнать тип переменной!

2)

Мы хотим четко указать диапазон или точность переменной (например, double, а не float)

На мой взгляд, случай, который здесь подходит, выглядит примерно так:

   double square(double d)
    {
        return d*d; 
    }

    int square(int d)
    {
        return d*d; 
    }

    auto a1 = square(3);

    cout << a1 << endl;

    a1 = square(3.3);

    cout << a1 << endl;

3)

Используя «auto», мы избегаем избыточности и написания длинных имен типов.

Представьте себе длинное имя типа из шаблонного итератора:

(код из раздела 6.3.6.1)

template<class T> void f1(vector<T>& arg) {
    for (typename vector<T>::iterator p = arg.begin(); p != arg.end();   p)
        *p = 7;

    for (auto p = arg.begin(); p != arg.end();   p)
        *p = 7;
}

В старом компиляторе auto был одним из способов вообще объявить локальную переменную. Вы не можете объявлять локальные переменные в старых компиляторах, таких как Turbo C, без ключевого слова auto или чего-то подобного.

Новое значение ключевого слова auto в C ++ 0x очень хорошо описано Стефаном Т. Лававей из Microsoft в видеолекции по STL, которую можно бесплатно просмотреть / загрузить, которую можно найти на сайте MSDN Channel 9 здесь .

Лекцию стоит просмотреть целиком, но часть ключевого слова auto находится примерно на 29-й минуте (приблизительно).

Есть ли у слова «авто» другое значение, кроме «локальная переменная»?

Не в C ++ 03.

Что-нибудь, что он делает, что явно не сделано для вас, где бы вы ни захотели его использовать?

Вообще ничего, в C ++ 03.

Как автоматическая переменная ведет себя в области программы? Что насчет статической автоматической переменной в области видимости файла?

Ключевое слово запрещено за пределами тела функции / метода.

Есть ли у этого ключевого слова какую-либо цель [в C ++ 03], кроме как просто существовать для полноты?

Удивительно, но да. Критерии разработки C ++ включают высокую степень обратной совместимости с C. В C было это ключевое слово, и не было реальной причины запрещать его или переопределять его значение в C ++. Итак, целью было на одну несовместимость с C.

Есть ли у этого ключевого слова какую-либо цель в C, кроме как просто существовать для полноты?

Я только недавно узнал об одном: простота переноса древних программ с B. C произошел от языка B, синтаксис которого был очень похож на C. Однако B не имел никаких типов. Единственный способ объявить переменную в B - указать ее тип хранения ( autoили extern). Как это:

авто я;

Этот синтаксис все еще работает в C и эквивалентен

int i;

поскольку в C по умолчанию используется класс хранения auto, а по умолчанию - тип int. Я предполагаю, что каждая отдельная программа, которая возникла в B и была перенесена на C, autoв то время была буквально полна переменных.

C ++ 03 больше не допускает неявного int в стиле C, но сохранил autoключевое слово no-more-точно-полезное, потому что, в отличие от неявного int, не было известно, что оно вызывает какие-либо проблемы в синтаксисе C.