For auto c что это

For auto c что это

Ограничения типа также можно использовать для ограничения типов, вместо которых используются заменители auto , auto* и auto& . Причем везде, где используется auto, также можно указывать ограничение типа: для определения локальных переменных, для типа результат функции, в лямбда-выражениях и т. д. Всякий раз, когда конкретный тип, который будет применяться вместо auto , не удовлетворяет ограничению типа, компилятор выдает ошибку.

#include #include template concept Numeric = std::integral || std::floating_point; Numeric auto sum(Numeric auto a, Numeric auto b) < const Numeric auto result; return result; > int main() < std::cout 

Здесь определен концепт Numeric , который предполагает, что тип T должен представлять целое число ( std::integral ), либо число с плавающей точкой ( std::floating_point ).

В определении функции sum рядом с заместителем типа auto применяем данный концеп, ограничивая возможный набор используемых типов, только числовыми типами. Причем это делам для типа результата функции:

Numeric auto sum

Для типа параметров

(Numeric auto a, Numeric auto b)

Для константы внутри функции

const Numeric auto result;

Затем можно вызывать эту функцию sum, передавая в нее числа, как целые, так и с плавающей точкой:

sum(10, 3) // 13 sum(10.6, 3.2) // 13.8

Ключевое слово `auto`

Ключевое слово auto означает, что переменная находится в automatic storage и время жизни такой переменной local lifetime. Другими словами, мы указывали, что данная переменная лежит в стеке, но так как все переменные созданные в функциях как

int a = 10; 

уже и так подразумивается, что они стековые - то это ключевое слово безсмысленное.

Начиная с С++11

Начиная с С++11 ключевое слово auto обретает новую жизнь. Оно говорит, что компилятор на этапе компиляции должен определить тип переменной на основе типа инициализируемого выражения.

#include #include #include using namespace std; class Foo < public: Foo( int x ) < >>; int main() < std::vector> arr; auto a = 166LL; auto b = 'a' + true; auto c = Foo(3); auto d = arr.begin(); cout

Особенности auto

1. Переменная auto должна быть объязательно проинициализирована
2. Переменная auto не может быть класс-мембером
3. Переменная auto не может быть параметром функции до С++14
   http://ideone.com/n7dZge
4. Тип auto не может быть возвращаемым типом функции до С++14. http://rextester.com/AFDFD63587

Холивар

Cторонники: есть типы данных в С++, которые портят читаемость когда своей длинной (про итераторы std::vector, к примеру) и хотелось бы писать меньше. Для modern C++ в условиях метапрограммирования возможность возврата типа auto делает шаблон гибким.
Противники: тип auto бьет по читабельности кода. Приходится гадать, что за переменная и делать лишнее действие в IDE наводя мышкой, чтобы понять что за тип. Такого рода "динамический тип" встает в разрез определению, что С++ строготипизированный язык.

Я же за использование auto в меру. Не надо впадаться в крайности.

auto в C

Почему строка auto a = 1; воспринимается компилятором C как корректная?

Я пользуюсь MS Visual Studio 2012, и вот этот код:

int main(void)

компилируется без ошибок, несмотря на то, что я использую расширение *.c исходника. Т.е. таким образом, я создаю код на чистом C, а насколько мне известно использование auto без указания типа стало возможным только в C++11 – заметьте, в C++, а не C.

Означает ли это, что у меня не так настроен компилятор, или этот код действительно корректен в C?

Ответ

auto – это старое ключевое слово C, обозначающее “локальную область видимости”. auto a эквивалентно auto int a, а в силу того, что в данном примере область видимости ограничена блоком, в котором объявлена переменная, то это то же самое, что и просто int a.

Это ключевое слово перешло в C еще из его предка, B, в котором не существовало базовых типов, а все было int(*): сами int‘ы, указатели на них, массивы int‘ов и т.п. И объявлялось все с помощью auto и extern. Подход “все, что тут есть – это int” в C было решено оставить, поэтому int‘овые переменные можно объявить и так:

auto a; extern b; static c; 

В стандарте ISO C от подобного подхода отказались, однако многие компиляторы все еще поддерживают bacward-совместимость. Если это кажется вам странным, то вспомните о том, что вот такая строка будет корректной:

unsigned d; // на самом деле unsigend int 

В C++ это слово вернули, но уже с новым смыслом (теперь эта конструкция позволяет явно не указывать тип переменной), ведь вряд ли множество программистов использовало это слово с оригинальным значением, особенно если учесть, что от “всего, что ты видишь – это int” отказались уже в C++98. Единственным исключением осталось тогда auto T a, чем все равно никто не пользуется.

Если вам не лень и очень интересно, можете покопаться в истории языка за авторством Страуструпа.

Кстати, интересно было организовано хранение строк в B. Строка была массивом int‘ов, каждый элемент которого хранил несколько символов. Таким образом, B – это тот же BCPL с другим синтаксисом.

Следите за новыми постами по любимым темам

Подпишитесь на интересующие вас теги, чтобы следить за новыми постами и быть в курсе событий.