Как инициализировать переменную в c
Перейти к содержимому

Как инициализировать переменную в c

  • автор:

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

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

тип имя_переменной — константа;

Ниже приведено несколько примеров

float balance = 123.23;

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

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

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

Напоминаем, что следующий короткий фрагмент сначала выделяет память для одной целочисленной переменной с именем x , а затем выделяет память еще для двух целочисленных переменных с именами y и z :

int x; // определяем целочисленную переменную с именем x int y, z; // определяем две целочисленные переменные с именами y и z

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

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

int width; // определяем целочисленную переменную с именем width width = 5; // копирующее присваивание значения 5 в переменную width // переменная width теперь имеет значение 5

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

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

#include int main() < int width; width = 5; // копирующее присваивание значения 5 в переменную width // переменная width теперь имеет значение 5 width = 7; // изменить значение, сохраненное в переменной width, на 7 // переменная width теперь имеет значение 7 return 0; >

Когда мы присваиваем значение 7 переменной width , значение 5, которое было там ранее, перезаписывается. Обычные переменные могут содержать только одно значение за раз.

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

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

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

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

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

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

int width = 5; // копирующая инициализация значения 5 в переменную width

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

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

int width(5); // прямая инициализация значения 5 в переменную width

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

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

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

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

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

int width; // прямая инициализация списком значения 5 в переменную width (предпочтительно) int height = ; // копирующая инициализация списком значения 6 в переменную height

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

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

int width<>; // инициализация значения значением 0

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

int width; // ошибка: не все значения типа double помещаются в int

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

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

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

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

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

Вопрос: Когда следует инициализировать с помощью , а когда с помощью <> ?

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

int x; // явная инициализация значением 0 std::cout 

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

int x<>; // инициализация значения std::cin >> x; // мы немедленно заменяем это значение

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

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

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

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

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

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

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

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

int a, b;

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

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

int a = 5, b = 6; // копирующая инициализация int c(7), d(8); // прямая инициализация int e, f; // инициализация списком (предпочтительно)

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

int a, b = 5; // неверно (a не инициализируется!) int a = 5, b = 5; // верно

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

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

int a, b(5); int c, d;

Этот код делает более ясным, что значение 5 используется только для инициализации переменной b или d , а не a или c .

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

Вопрос 1

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

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

Вопрос 2

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

Прямая инициализация списком.

Переменные

Синтаксис объявления переменных в C# выглядит следующим образом:

int i;

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

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

Инициализация переменной

Задать значение переменной можно, в частности, с помощью оператора присваивания. Кроме того, задать начальное значение переменной можно при ее объявлении. Для этого после имени переменной указывается знак равенства (=) и присваиваемое значение. Если две или более переменные одного и того же типа объявляются списком, разделяемым запятыми, то этим переменным можно задать, например, начальное значение. Ниже приведена общая форма инициализации переменной:

int i = 10; // задаем целочисленной переменной i значение 10 char symbol = 'Z'; // инициализируем переменную symbol буквенным значением Z float f = 15.7F; // переменная f инициализируется числовым значением 15.7 int x = 5, y = 10, z = 12; // инициализируем несколько переменных одного типа

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

В C# используются два метода для обеспечения инициализации переменных перед пользованием:

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

Например, в C# поступить следующим образом нельзя:

Переменные в языке C++

Объявление переменной в языке C++ в общем случае делается используя следующий синтаксис:

<тип> <имя_переменной>[, <имя_переменной>]. ;

  • - это дип данных, который будет использоваться для всех указанных переменных
  • - символьное имя переменной

Правила именования переменных:

  • имя переменной может состоять только из латинских букв, цифр и символа подчеркивания
  • прописные и строчные буквы в именах различаются, то есть переменные abc и Abc - разные переменные
  • имя переменной не может начинаться с цифры
  • имя переменной не может повторяться, то есть нельзя объявить две переменные с одним именем
  • в качестве имени переменной не могут использоваться ключевые слова языка C++. Список таких слов следующий: alignas, alignof, asm, auto, bool, break, case, catch, char, char16_t, char32_t, class, const, constexpr, const_cast, continue, decltype, default, delete, do, double, dynamic_cast, else, enum, explicit, export, extern, false, float, for, friend, goto, if, inline, int, long, mutubale, namespace, new, noexcept, nullptr, operator, private, protected, public, register, reinterpret_cast, return, short, signed, sizeof, static, static_assert, static_cast, struct, switch, template, this, thread_local, throw, true, try, typedef, typeid, typename, union, unsigned, using, virtual, void, volatile, wchar_t, while.

Переменные в языке C++ могут объявляться в любом месте программы, но должны быть объявлены до первого их использования.

int a; float b, c; char str_v1, d, e;

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

Инициализация переменной - это объявление переменной, с одновременным присваиванием ей какого-то значения.

В C++ существует три типа инициализации:

  • копирующая инициализация
  • прямая инициализация
  • универсальная инициализация (C++ 11)
Копирующая инициализация

<тип> <имя_переменной>[ = <значение>][, <имя_переменной>[ = <значение>]]. ;

int a = 0, b, c = 12; // инициализированы переменные a и c float f = 1.2f, e; // инициализирована только переменная f, у переменной e - неопределенное значение double g, d = 3.145; // инициализирована только переменная d, у переменной g - неопределенное значение

При объявлении переменных можно инициализировать не все переменные. Если переменная не инициализируется, ее значение будет неопределенным.

Прямая инициализация

<тип> <имя_переменной>[ (<значение>) ][, <имя_переменной>[ (<значение>) ]]. ;

int a(1), b, c(3), d; // инициализированы переменные a и c
Универсальная инициализация

Прямая или копирующая инициализация работают не со всеми типами данных (например, вы не сможете использовать эти способы для инициализации списка значений). В попытке обеспечить единый механизм инициализации, который будет работать со всеми типами данных, в C++11 добавили новый способ инициализации.

<тип> <имя_переменной>[ <значение>> ][, <имя_переменной>[ <значение>> ]]. ;

int a< 1 >, b, c< 3 >, d; // инициализированы переменные a и c int e<>; // переменная инициализируется значением по-умолчанию для типа, в данном случае 0

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

int a = 4.5; // предупреждение при компиляции int b(4.5); // предупреждение при компиляции int c; // ошибка компиляции

Добавить комментарий

Ваш адрес email не будет опубликован. Обязательные поля помечены *