В прошлой статье мы научились определять переменные, в которых можно будет хранить различные данные (значения). В этой статье мы научимся помещать данные в переменную различными способами.
Повторим прошлый материал для закрепления:
____________________________________________________________________________________
int x;
int m, k;
____________________________________________________________________________________
В этом фрагменте кода на первой строке мы выделяем (определяем) место в памяти для целочисленной переменной х, а потом на второй строчке для двух целочисленных переменных m и k.
Оператор присваивания
После того, как переменная была определена, ей можно присвоить значения используя специальный оператор. Он называется оператором присваивания. Выглядит это так:
Как это работает?
Оператор присваивания "=" буквально говорит, возьми значение указанное справа и помести его в переменную слева. Его еще называют копирующим присваиванием, так как он копирует значение в переменную.
Перезапись значения
После присваивания переменной, мы можем перезаписать ее значение, старое значение будет отброшено, а на его место придет новое, которое мы перезапишем. Выглядит это так:
Да, как вы видите, перезапись значения происходит с помощью того же оператора присваивания. Вы можете перезаписывать значение столько раз, сколько захотите.
Для практики, попробуйте сделать это сами несколько раз в вашей IDE, чтобы увидеть наглядный результат (увидеть, что значение перезаписано), воспользуйтесь выводом перезаписанной переменной на экран, как в следующем коде:
____________________________________________________________________________________
#include <iostream>
int main()
{
int x;
x = 10;
x = 15;
std::cout << x;
return 0;
}
____________________________________________________________________________________
Строка std::cout << x; выведет на экран последнее перезаписанное в переменную значение, если вы решите скомпилировать и запустить эту программу.
Инициализация переменных
У присваивания есть несколько недостатков, главный и волнующий нас — это необходимость сначала определять переменную и только потом присваивать ей нужное нам значение.
Эту проблему решает метод инициализации.
Суть его в том, чтобы сразу указывать начальное значение переменной при ее определении.
Основные способы инициализации
В С++ доступны три основных способа инициализации:
- Копирующая инициализация.
- Прямая инициализация с помощью круглых скобок.
- Инициализация списком.
Рассмотрим каждый из них подробнее.
Копирующая инициализация — это, по сути определение и присваивание значения через оператор "=" на одной строке. Выглядит это так:
Тут используется тот же принцип, что и в прошлом блоке статьи. Инструкция на строке 4 говорит: возьми целочисленное значение 4 и присвой его целочисленной переменной x.
Прямая инициализация с помощью скобок — это упрощение копирующей инициализации. Инструкцию для нее можно прочитать так: значение в круглых скобкам помещено в переменную x.
Вот так это выглядит:
Использование прямой или копирующей инициализации не меняет сути кода, если речь идет о простых типах данных, таких как целые числа. Различия между этими двумя видами инициализации мы рассмотрим в другой статье. Пока их достаточно просто знать.
Прямую и копирующую инициализацию не всегда возможно использовать. Для обеспечения согласованного со всеми ситуациями типа инициализации, в C++ есть инициализация с фигурными скобками, иначе называемая унифицированной инициализацией или инициализацией списком.
Она выглядит так:
Представленный пример показывает, что вы можете использовать для инициализации списком, как прямой способ (строка 4), так и копирующий (строка 6).
Совет: Прямая форма инициализации списком более предпочтительна.
Инициализация с пустым значением
Бывают ситуации, в которых у вас появится необходимость инициализации переменной без присваивания ей значения. В таком случае вы можете инициализировать переменную с пустым (нулевым) значением. Вот так это можно сделать:
____________________________________________________________________________________
#include <iostream>
int main()
{
int x{};
std::cout << x;
return 0;
}
____________________________________________________________________________________
В этом примере кода, мы не только инициализируем переменную x пустым значением, но и выводим ее на экран. Скопируйте себе этот блок кода, скомпилируйте и запустите его. В консольном окне вы получите единственный результат: 0
Одно из важных преимуществ инициализации списком в ее предельной точности по отношению к типу данных, к которому принадлежит переменная. Проще говоря, если вы инициализируете переменную целочисленного типа с дробным значением, то ваш компилятор выдаст предупреждение или покажет на ошибку.
В случае с копирующей или обычной прямой инициализацией произойдет так называемое сужающее преобразование. И число после запятой просто будет отброшено. Однако это не является преимуществом этих видов инициализаций, над списочной. На это есть две причины:
1. Переменная одного типа не может безопасно удерживать внутри значение другого типа.
2. Точность значения, при отбрасывании его части становится ниже, что во многих проектах будет критично для программиста.
Теперь разберем на примерах то, о чем мы говорили:
1. В блоке кода, расположенном ниже, мы используем прямую и копирующую инициализацию переменных, чтобы поместить в них значения типа double (дробное число), не соответствующие типам переменных integer (целое число)
Попробуйте скопировать этот блок кода, скомпилировать и запустить его:
____________________________________________________________________________________
#include <iostream>
int main()
{
int x = 1.5;
int y(17.4);
std::cout << x << "\n" << y;
return 0;
}
____________________________________________________________________________________
В консоли вы получите числа: 1 и 17, расположенные на разных строках. Как вы видите, при такой инициализации компилятор просто отбросил дробные части чисел.
Теперь попробуйте запустить этот вариант кода:
____________________________________________________________________________________
#include <iostream>
int main()
{
int x = { 1.5 };
int y{17.4};
std::cout << x << "\n" << y;
return 0;
}
____________________________________________________________________________________
Вы получили две ошибки. В VS Microsoft они будут выглядеть так:
Резюме (субъективный совет): Отдайте предпочтение инициализации списком при создании и присвоении значений новым переменным.
Типичные ошибки новичков
1. Инициализация переменных по желанию.
Инициализируйте переменные всегда, кроме частных случаев, где есть необходимость поступить по другому.
Несоблюдение этого правила, ведет за собой:
- Появление менее читаемого кода.
- Объявление имен, в большем, чем нужно, объеме.
- Логические ошибки, усложнение кода.
- Нарастание проблем во время поддержки и изменения кода (проблемы рефакторинга)
2. Создание нескольких переменных на одной строке, но неправильная их инициализация
На приведенной ниже строке кода, инициализируется только переменная z:
____________________________________________________________________________________
int x, y, z{};
____________________________________________________________________________________
Чтобы инициализировать все, дайте значение каждой из них:
____________________________________________________________________________________
int x{}, y{}, z{};
int x = 0, y =0, z = 0;
____________________________________________________________________________________
Вместо заключения
В заключение этой статьи скажу, что я рекомендую вам чаще писать все, что вы изучаете в собственном редакторе. Когда вы пишите код, а не просто читаете примеры, любой материал лучше запоминается.
Хотите узнать немного подробнее о том, почему переменные необходимо инициализировать? Читайте эту статью.
Спасибо за уделенное время. Подписывайтесь на канал, чтобы не пропустить новые материалы. Оставляйте реакции и комментарии.