Что значит инициализировать переменную

Урок №28. Инициализация, присваивание и объявление переменных

Обновл. 11 Сен 2021 |

Этот урок является более детальным продолжением урока №10.

Адреса и переменные

Как вы уже знаете, переменные — это имена кусочков памяти, которые могут хранить информацию. Помним, что компьютеры имеют оперативную память, которая доступна программам для использования. Когда мы определяем переменную, часть этой памяти отводится ей.

Поскольку все данные компьютера — это лишь последовательность битов, то мы используем тип данных (или просто «тип»), чтобы сообщить компилятору, как интерпретировать содержимое памяти. Вы уже видели пример типа данных: int (целочисленный тип данных). Когда мы объявляем целочисленную переменную, то мы сообщаем компилятору, что «кусочек памяти, который находится по такому-то адресу, следует интерпретировать как целое число».

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

Кроме int, есть много других типов данных в языке C++, большинство из которых мы детально рассмотрим на соответствующих уроках.

Фундаментальные типы данных в С++

В языке C++ есть встроенная поддержка определенных типов данных. Их называют основными типами данных (или «фундаментальные/базовые/встроенные типы данных»).

Вот список основных типов данных в языке C++:

Категория	Тип	Значение	Пример
Логический тип данных	bool	true или false	true
Символьный тип данных	char, wchar_t, char16_t, char32_t	Один из ASCII-символов	‘c’
Тип данных с плавающей запятой	float, double, long double	Десятичная дробь	3.14159
Целочисленный тип данных	short, int, long, long long	Целое число	64
Пустота	void	Пустота

Объявление переменных

Вы уже знаете, как объявить целочисленную переменную:

Источник

Переменные

Переменные

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

auto	double	int	struct
break	else	long	switch
register	typedef	char	extern
return	void	case	float
unsigned	default	for	signed
union	do	if	sizeof
volatile	continue	enum	short
while	inline

А также ряд других слов, специфичных для данной версии компилятора, например far, near, tiny, huge, asm, asm_ и пр.

Типы переменных

Целые

Указанные выше значения характерны для компилятора VC2012 на 32-разрядной машине. Так что, если ваша программа зависит от размера переменной, не поленитесь узнать её размер.

Таб. 1 Размер целых типов в си.

Тип	Размер, байт	Минимальное значение	Максимальное значение
unsigned char	1	0	255
signed char ( char )	1	-128	127
unsigned short	2	0	65535
signed short ( short )	2	-32768	32767
unsigned int ( unsigned )	4	0	4294967296
signed int ( int )	4	-2147483648	2147483647
unsigned long	4	0	4294967296
signed long ( long )	4	-2147483648	2147483647
unsigned long long	8	0	18446744073709551615
signed long long ( long long )	8	-9223372036854775808	9223372036854775807

sizeof

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

(Я думаю ясно, что переменные могут иметь любое валидное имя). Эту программу можно было написать и проще

В си один и тот же тип может иметь несколько названий
short === short int
long === long int
long long === long long int
unsigned int === unsigned

Типы с плавающей точкой

Переполнение переменных

Си не следит за переполнением переменных. Это значит, что постоянно увеличивая значение, скажем, переменной типа int в конце концов мы «сбросим значение»

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

Постфиксное обозначение типа

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

Шестнадцатеричный и восьмеричный формат

В о время работы с числами можно использовать шестнадцатеричный и восьмеричный формат представления. Числа в шестнадцатиричной системе счисления начинаются с 0x, в восьмеричной системе с нуля. Соответственно, если число начинается с нуля, то в нём не должно быть цифр выше 7:

Экспоненциальная форма представления чисел

Объявление переменных

При объявлении переменной пишется её тип и имя.

Можно объявить несколько переменных одного типа, разделив имена запятой

Здесь объявлены переменные a и b внутри функции main, и переменная z внутри тела цикла. Следующий код вызовет ошибку компиляции

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

Начальное значение переменной

Область видимости переменной

П еременные бывают локальными (объявленными внутри какой-нибудь функции) и глобальными. Глобальная переменная видна всем функциям, объявленным в данном файле. Локальная переменная ограничена своей областью видимости. Когда я говорю, что переменная «видна в каком-то месте», это означает, что в этом месте она определена и её можно использовать. Например, рассмотрим программу, в которой есть глобальная переменная

Будет выведено
foo: 100
bar: 333
Здесь глобальная переменная global видна всем функциям. Но аргумент функции затирает глобальную переменную, поэтому при передаче аргумента 333 выводится локальное значение 333.
Вот другой пример

Программа выведет 555. Также, как и в прошлом случае, локальная переменная «важнее». Переменная, объявленная в некоторой области видимости не видна вне её, например

Этот пример не скомпилируется, потому что переменная y существует только внутри своего блока.
Вот ещё пример, когда переменные, объявленные внутри блока перекрывают друг друга

Программа выведет
30
20
10
Глобальных переменных необходимо избегать. Очень часто можно услышать такое. Давайте попытаемся разобраться, почему. В ваших простых проектах глобальные переменные выглядят вполне нормально. Но представьте, что у вас приложение, которое

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

Безусловно, есть ситуации, когда глобальные переменные упрощают программу, но такие ситуации случаются не часто и не в ваших домашних заданиях, так что НЕ СОЗДАВАЙТЕ ГЛОБАЛЬНЫХ ПЕРЕМЕННЫХ!
Переменные могут быть не только целочисленными и с плавающей точкой. Существует множество других типов, которые мы будем изучать в дальнейшем.

Источник

1.4 – Присваивание и инициализация переменных

В предыдущем уроке «1.3 – Знакомство с переменными в C++» мы рассмотрели, как определить переменную, которую мы сможем использовать для хранения значений. В этом уроке мы узнаем, как помещать значения в переменные, и как использовать эти значения.

Присваивание значения переменной

Копирующее присваивание названо так, потому что оно копирует значение с правой стороны оператора = в переменную с левой стороны оператора. Оператор = называется оператором присваивания.

Вот пример, где мы используем присваивание дважды:

Предупреждение

Одна из наиболее распространенных ошибок, которые делают новички, – это путать оператор присваивания ( = ) с оператором равенства ( == ). Присваивание ( = ) используется для присвоения значения переменной. Равенство ( == ) используется для проверки того, равны ли два операнда по значению.

Копирующая и прямая инициализации

Одним из недостатков присваивания является то, что для него требуются как минимум две инструкции: одна для определения переменной, а другая для присвоения значения.

Эти два шага можно совместить. При определении переменной вы также можете одновременно указать для нее начальное значение. Это называется инициализацией.

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

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

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

Для простых типов данных (например, целых чисел) копирующая и прямая инициализации, по сути, одинаковы. Различия между копирующей инициализацией и прямой инициализацией мы увидим в этой серии статей позже.

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

Инициализации списком

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

Инициализация списком бывает двух форм:

Эти две формы функционируют почти одинаково, но обычно предпочтительнее прямая форма.

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

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

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

По возможности отдавайте предпочтение прямой инициализации списком.

Вопрос: C++ обеспечивает копирующую, прямую инициализации и инициализацию списком, а также копирующее присваивание. Существует ли прямое присваивание или присваивание списком?

Нет, C++ не поддерживает синтаксис прямого присваивания или присваивания списком.

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

Используйте инициализацию значения, если значение временное и будет заменено.

Инициализируйте свои переменные

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

Для более подробного обсуждения этой темы Бьёрн Страуструп (создатель C++) и Герб Саттер (эксперт по C ++) сами дают рекомендацию здесь.

Мы исследуем, что произойдет, если вы попытаетесь использовать переменную, для которой нет четко определенного значения, в уроке «1.6 – Неинициализированные переменные и неопределенное поведение».

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

Инициализируйте свои переменные при создании.

Инициализация нескольких переменных

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

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

Вы можете инициализировать несколько переменных, определенных в одной строке:

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

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

Лучший способ запомнить, что это неправильно, – рассмотреть случай прямой инициализации или инициализации списком:

Небольшой тест

Вопрос 1

В чем разница между инициализацией и присваиванием?

Инициализация дает переменной начальное значение в момент ее создания. Присваивание дает переменной значение в какой-то момент после создания.

Вопрос 2

Какую форму инициализации следует использовать?

Источник

Объявление? Определение? Инициализация?

Объявление? Определение? Инициализация?

В чем разница между объявлением переменной, её определением и инициализацией

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

Такими близкими по смыслу и довольно часто путающимися являются понятия «объявление» переменной, её «определение» и её «инициализация».

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

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

Объявление переменной или константы

В приведенном примере задана переменная (var), задано имя переменной (а) и задано значение переменной (10).

Определение переменной или константы

Как известно, объявить переменную мы можем и без указания значения. Но тогда нужно указать тип данных будущего значения.

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

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

И кстати, для чистоты кода в Swift рекомендуется не ставить пробел между именем переменной и двоеточием.

Инициализация переменной или константы

В первом примере, который мы продублируем ниже, где происходит не только объявление переменной, но и её инициализация:

Инициализация означает, что переменная запущена в работу, ей присвоено начальное значение, она инициализирована. Без присвоения начального значения переменная просто объявлена, а с начальным значением она еще и инициализирована.

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

Но, как мы помним, Swift рекомендует экономить время, если есть значение, он может самостоятельно определить тип данных.

Ковбойская история

Разницу между этими тремя действиями можно проиллюстрировать с помощью шуточного примера, найденного на просторах интернета и немного подредактированного))

Заметка

Обратите внимание, что мы используем выражение «тип данных» и по отношению к значению, и по отношению к переменным и константам. Дело в том, что в программировании по большому счета можно практически все называть типом данных. Это и объекты, и классы, и наиболее нам известные Int, String, Double, Bool и т.д.
Но, чтобы как-то все же отличать типы данных значений от констант и переменных будем называть последние некими сущностями, элементами языка программирования. Тогда у нас будут типы данных для значений и типы данных для определенных элементов программирования (к которым относятся в том числе константы и переменные).

Источник

Java Core для самых маленьких. Часть 3. Переменные

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

На скриншоте выше продемонстрирован пример создания переменных.

Давайте сразу научимся давать имена переменным правильно. Существует документ Java Code Conventions. В нем указаны правила к написанию кода на Java. Нужно это для того, что бы Java код в разных проектах был написан в едином стиле. Таким образом, новоприбывший на проект программист не будет отвлекаться на новый стиль кода, ведь он будет оформлен так же, как и на других проектах. Эти правила работают и при нейминге переменных.

Итак, переменные принято называть в lowerCamelCase стиле. Сейчас покажу как хорошо, а как плохо:

Вот было значение 1998, а на следующей строке стало 2000. А вот с константой так не получится. Константа гарантирует, что ее значение не изменится на протяжении всего времени выполнения программы. Как создать константу? Очень просто:

Нужно всего лишь дописать ключевое слово final перед типом данных переменной. Для простоты понимания, мы как бы «финализируем» значение переменной и говорим, что это значение конечное.

Обратим внимание на имя константы. Когда мы даем имя константе, то должны делать это в стиле SCREAMING_SNAKE_CASE. Давайте исправим мой код:

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

Инициализация переменных

У всех переменных из моих примеров уже было присвоено начальное значение. Процесс присвоения начального значения называется инициализацией переменной. И не обязательно инициализировать переменную во время ее объявления. Java позволяет сделать это и позже.

Во-первых, можно объявлять переменные через запятую (если они одинакового типа):

При этом, смотрите, мы можем некоторые из них инициализировать прямо во время объявления. А теперь инициализируем оставшиеся:

Для инициализации переменных типа char я использовал цепочку присваиваний. Да, и так тоже можно. Хотя используется очень редко.
Если мы попытаемся провести какую-то операция с переменной, у которой нет значения, то получим ошибку.

Оператор присваивания

Литералы

В Java постоянные значения задаются литеральным представлением. Простым языком, при помощи определенных символов мы можем указывать тип данных. Вот например, при работе с целочисленными литералами нам не нужны никакие литералы. Мы просто пишем число 1998; и Java понимает, что это целочисленное значение.

Так, что еще за символы подчеркивания в значении переменной? Это всего-навсего декор. С JDK 7 допустимо указывать знаки подчеркивания, для разбиения больших чисел на разряды, для удобства чтения.

В вышеописанных примерах были литералы для целочисленных десятичных значений. А еще мы можем присвоить целому числу литерал в виде восьмеричного значения. Для этого вам нужно добавить в самом начале значения 0. Но в таком случае, логично, что это значение не сможет содержать цифры 8 и 9, поскольку они выходят за пределы восьмеричной системы счисления.

Мало того, еще мы можем использовать литерал шестнадцатеричных значений. Такие значения обозначают с начальным 0x или 0X, а цифры в пределах от 10 до 15 заменяются символами ABCDEF английского алфавита.

С JDK 7 есть возможность указывать целочисленные литералы в двоичном виде. Для этого вначале значения нужно указать 0b или 0B и соответственно в значениях можно использовать только цифры 0 и 1. В реальности, вам навряд ли понадобятся литералы шестнадцатеричных, восьмеричного или двоичных значений. Однако, знать о них нужно.

Литералы дробных чисел

Но существует и экспоненциальная форма записи этих чисел в виде 2.34e12;

Где число после символа ‘e’ обозначает степень 10-ти. Простыми словами, мы записали 2 целых и 34 сотых умноженное на 10 в 12 степени.

Как и в случае с целочисленными значениями, литералы с плавающей точкой поддерживают нижнее подчеркивание начиная с JDK 7.

Логические литералы

Символьные литералы

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

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

А вот если символ нельзя ввести непосредственно с клавиатуры, то для ввода таких символов используют ряд управляющих последовательностей. Например, символ переноса строки ‘\n’. Существуют последовательности, которые существуют для ввода значений в восьмеричной и шестнадцатеричной форме. Например, мы захотели ввести букву tu катаканы смайлик: ツ. Берем и пишем:

В данной таблице вы можете посмотреть наиболее используемые последовательности символов:

Когда-то давно, я писал статью про экранирование символом. Настоятельно рекомендую прочитать, как дополнительный материал. Узнаете много интересного.

Строковый литерал

Можно заключить последовательность символов в двойные кавычки и получить так называемую строку.

Динамическая инициализация

Пару слов о таком термине как динамическая инициализация. Ничего сложного, только звучит страшно.

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

Главное, чтобы тип данных выражения / инициализирующей переменной совпадал с типом данных целевой переменной.

Преобразование и приведение типов

Знаю, вы уже подустали, сделали массу перерывов и подходов. Обещаю, это последняя тема в этой статье.

Часто программисты сталкиваются с ситуацией, когда переменной одного типа приходится присваивать значение другого типа. Если оба типа данных совместимы, их преобразование будет выполнено автоматически. Для автоматического преобразования должно выполняться 2 условия:

Чтобы выполнить преобразование двух несовместимых типов данных, нужно воспользоваться приведением типов. Это явное преобразование одного типа в другой. И выглядит это вот так:

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

Подводим итоги

В этой статье мы поговорили о многих важных вещах. Узнали, как создавать переменные и константы в Java, и чем они отличаются. Узнали о способах инициализации переменных. Разобрались с тем, что такое литералы и какие они бывают. А так же выполнили преобразование и приведение типов данных.

Скажем спасибо Егору за предоставленный материал.

Источник