Невозможно вывести тип авто требуется инициализатор

Почему тип auto недопустим?

Явно используется тип с плавающей запятой: double или float. В чем проблема то?

Это стандартная тема, насколько мне известно, проблем не возникнет.

Виртуальные функции и тип auto
Хочу написать генератор рандомных значений разных типов как это можно реализовать? вот наброски (но.

Заменить auto на необходимый тип итератора
Есть структура typedef std::vector Resp; struct View < // объявляем структуру для.

Тип auto в старых версиях компиляторов
Здравствуйте. Пытаюсь работать с данным циклом, но компилятор выдаёт ошибки. У меня не новая версия.

Как компилятор должен понять что будет именно передаваться, сколько памяти надо выделить и прочие?

Вообще авто не стоит использовать, вы же программист, вы что не знаете какой тип данных у вас работает?

а такая запись, если мне не изменяет память, доступна только в c++14. Но могу заблуждаться

Добавлено через 10 минут

Добавлено через 4 минуты

Battary, Почитайте лучше побольше про auto. Он в первую очередь создавался для конструкций, вида

2ТС спп это вообще строго типизированный язык. И с авто не стоит играется, иначе когда софтинка будет так строк на 1000, с отладкой будут суровые проблемы. Если прям совсем лень работать с типами, стоит задуматься о варианте другого языка, например JS, или если хочется что то серьезное то NodeJS

PS хотя я не представляю как можно работать с переменными, когда у тебя там может быть и int и double и строка и вообще объект, это для меня ужас)

Источник

8.7 – Вывод типов для объектов с использованием ключевого слова auto

В этом простом определении переменной скрывается небольшая избыточность:

Связанный контент

Мы обсуждали, как определяются типы литералов в уроке «4.13 – Литералы».

В случаях, когда мы хотим, чтобы переменная и ее инициализатор имели один и тот же тип, мы фактически предоставляем информацию одного и того же типа дважды.

Вывод типа для инициализированных переменных

Вывод типа (или англоязычные термины type inference и type deduction) – это функция, которая позволяет компилятору определять тип объекта из его инициализатора. Чтобы использовать вывод типа, вместо типа переменной используется ключевое слово auto :

Поскольку вызовы функций являются допустимыми выражениями, мы можем использовать вывод типа, даже когда наш инициализатор является вызовом функции:

Вывод типа не будет работать для объектов, у которых нет инициализаторов, или у которых пустые инициализаторы. Таким образом, следующее недопустимо:

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

Вывод типа отбрасывает квалификаторы const

В большинстве случаев вывод типа удаляет квалификатор const из выводимых типов. Например:

Если вы хотите, чтобы выведенный тип был константным, вы можете использовать ключевое слово const вместе с ключевым словом auto :

Для продвинутых читателей

Вывод типа не удаляет квалификатор const для указателей на константные значения, такие как типы, выведенные из строковых литералов в стиле C.

Выведение типа отбрасывает ссылки

Для продвинутых читателей

Мы еще не рассмотрели ссылки, но определение типа также отбрасывает ссылки.

Вы также можете вывести константную ссылку, используя const auto&

Преимущества и недостатки вывода типа

Вывод типа не только удобен, но и имеет ряд других преимуществ.

Во-первых, если две или более переменных определены в соседних строках, имена переменных будут выровнены, что поможет повысить удобочитаемость:

Во-вторых, вывод типа работает только с переменными, у которых есть инициализаторы, поэтому, если вы привыкли использовать вывод типа, он может помочь избежать непреднамеренно неинициализированных переменных:

В-третьих, вам гарантировано отсутствие непреднамеренных преобразований, влияющих на производительность:

У вывода типа также есть несколько недостатков.

Во-первых, вывод типа скрывает информацию о типе объекта в коде. Хотя хорошая IDE должна иметь возможность показать вам выведенный тип (например, при наведении курсора на переменную), всё же при использовании вывода типа немного легче делать ошибки, связанные с типами.

Вот еще один пример:

В этом примере менее очевидно, что мы получаем целочисленное деление, а не деление с плавающей запятой.

Во-вторых, если тип инициализатора изменится, тип переменной, использующей вывод типа, также изменится, возможно, неожиданно. Рассмотрим код:

Для продвинутых читателей

В-третьих, поскольку при выводе типов ссылки отбрасываются, если вы используете » auto » вместо » auto& «, ваш код может не работать так же хорошо или даже работать некорректно.

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

Лучшая практика

Используйте вывод типа для переменных, если вам не нужно фиксировать конкретный тип.

Примечание автора

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

Источник

auto (C++)

Выводит тип объявленной переменной из выражения инициализации.

Стандарт C++ определяет исходное и измененное значение для этого ключевого слова. до Visual Studio 2010, auto ключевое слово объявляет переменную в auto классе хранения, то есть переменную с локальным временем существования. начиная с Visual Studio 2010, auto ключевое слово объявляет переменную, тип которой выведен из выражения инициализации в его объявлении. /Zc:auto[-] Параметр компилятора управляет значением auto ключевого слова.

Синтаксис

auto инициализатор auto

[](auto [](auto , auto , auto ) <>;

Remarks

auto Ключевое слово направляет компилятору использование выражения инициализации объявленной переменной или параметра лямбда-выражения, чтобы вывести его тип.

Рекомендуется использовать auto ключевое слово для большинства ситуаций, если только не требуется преобразование, так как оно предоставляет следующие преимущества:

Надежность: Если тип выражения изменился — это включает в себя изменение типа возвращаемого значения функции — это просто работает.

Производительность: Вы гарантируете, что преобразование не будет выполнено.

Удобство использования: Не нужно беспокоиться о неправильном написании имени типа и опечатке.

Эффективность: Написание кода может быть более эффективным.

Варианты преобразования, в которых может не потребоваться использовать auto :

Если необходимо получить конкретный тип.

auto Выражение инициализации может принимать несколько форм:

Дополнительные сведения см. в разделе инициализаторы и примеры кода далее в этом документе.

Удобство

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

Можно также использовать auto для объявления и инициализации переменной в лямбда-выражении. Вы не сможете самостоятельно объявить тип переменной, поскольку тип лямбда-выражения известен только компилятору. Дополнительные сведения см. в разделе Примеры лямбда-выражений.

Отслеживание возвращаемых типов

Ссылки и cv-квалификаторы

Обратите внимание, что использование удаления auto ссылок, const квалификаторов и volatile квалификаторов. Рассмотрим следующий пример.

Выведение типа с инициализаторами в фигурных скобках (C++ 14)

В следующем примере кода показано, как инициализировать auto переменную с помощью фигурных скобок. Обратите внимание на разницу между B и C и между A и E.

Ограничения и сообщения об ошибках

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

Примеры

Эти фрагменты кода иллюстрируют некоторые способы auto использования ключевого слова.

Следующие объявления эквивалентны, но второе объявление проще первого. Одной из наиболее интересных причин использования auto ключевого слова является простота.

В следующем фрагменте кода объявляется тип переменных iter и elem при for for запуске циклов и диапазонов.

В следующем фрагменте кода используется new объявление оператора и указателя для объявления указателей.

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

Источник

Путаница по типу «авто»

Это нормально, отлично работает. Но,

компилятор дает ошибку.

Итак, почему компилятор дает ошибку?

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

Можно утверждать, что компилятор может смотреть дальше, чтобы вывести тип, но это было бы дополнительными усилиями для небольшой ценности, поэтому вряд ли это уступит место в будущем C++. И какой тип будет выведен в следующем примере:

Проект в разделе 7.1.6.4 авто спецификатора имеет эту запись

Спецификаторы auto и decltype (auto) используются для обозначения типа заполнителя, который позже будет заменен выводом из инициализатора.

Следовательно, auto и decltype(auto) требуется инициализатор.

не будет компилироваться, поскольку компилятор не может вывести тип i без инициализатора.
Также,

Не будет работать, поскольку auto выводит тип i из его инициализатора, и в этом случае у вас нет инициализатора.

С другой стороны, это работает:

Автоматический тип должен быть выведен компилятором, и после того, как он будет установлен, он не может быть изменен. Это операция времени компиляции. Поэтому ему нужна инициализация. Это на самом деле точка в ней, обеспечивающая переменную инициализацию, перемещая все в правую сторону от =

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

Стандарт С++ 11:

3 В противном случае тип переменной выводится из ее инициализатора. Имя объявляемой переменной не должно появляться в выражении инициализатора.

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

И стандарт утверждает, что он будет выводить его только из инициализатора, который должен быть частью декларации.
Он может легко выглядеть немного дальше, возможно, по крайней мере, как метод возврата-типа для функций лямбда и C++ 14, что означает первое задание.
Или он может даже попытаться синтезировать совместимый тип из всех мест, которые он использует, как это делают некоторые другие языки, но это довольно усложняло бы правила.

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

дают тот же наблюдаемый результат, но они не эквивалентны. Первые сначала объявляют переменную и присваивают ей значение, последняя объявляет переменную и инициализирует ее. Таким образом, это фактически эквивалентно int i(0);

Это причина, по которой auto i=0; имеет смысл: он определяет переменную i того же типа, ее инициализатор (здесь простой int ). Но auto i; вызывает ошибку компиляции, поскольку в момент компиляции процесс обрабатывает объявление, он не знает, какой тип должен быть.

Источник

vector template vector ::iterator
Здраствуйте! При написании вектора столкнулся с проблемой такого рода: вот код вектора template.

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

Добавлено через 3 минуты
На твой код ругается так:

«авто» нет такого ключевого слова
есть auto и он работает

И перегрузить оператор вывода для вашей структуры.

По коду можно сказать очень много замечаний, но вы же их игнорируете..

Она не поддерживает range based for loop. Лучше, конечно, скачать версию посвежее (я вроде бы это раньше вам уже говорил).

Плохо мешать имена типов и имена переменных. Мб поэтому у вас код и не компилируется. Более того, начинать имена с нижнего подчёркивания нельзя, эти имена зарезервированы для разработчиков компиляторов. Так что переименуйте структуру и вектор.

Добавлено через 1 минуту

Нет, компилятор вполне может разобраться. А вот человек может ошибиться (вы явный тому пример). Я уже указывал автору в другой теме, что так лучше не делать.

Добавлено через 2 минуты
Кстати, ваш код не будет компилироваться на VS2010 т.к. она не поддерживает Initializer lists
https://blogs.msdn.microsoft.c. sual-c-11/

То, что он может разобраться, совсем не значит, что он разберётся. И именно это Вы указывали тому человеку в другой теме, полагаю.

Добавлено через 9 минут

Мой код содержит в себе ответ на вопрос, которым задался ТС.
Если это действительно так, то то, что мой код не будет компилироваться в древних студиях, не имеет никакого значения.

комп не тянет
студии грузит минут по 10, и глючит сильно

А как тогда писать переменные, если они начинаются с цифр?
нам в вузе говорили, что переменные начинающиеся с цифр, точно (любые) можно писать начиная с нижнего подчеркивания,
так как в студии если переменные и начинаются с нижнего подчеркивания, то далее идет буква

хорошо, а два подчеркивания будет норм?
или обязательно без них?

Писать-то их можно, но в языке С++ такое именование прерогатива разработчиков компиляторов. Поэтому давать переменным имена, начинающиеся с подчёркиваний не нужно, это может привести к неожиданным последствиям в серьёзной программе.

Источник