Как ввести переменную в с

Инструкции объявления

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

string greeting; int a, b, c; List xs; 

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

string greeting = "Hello"; int a = 3, b = 2, c = a + b; List xs = new(); 

В предыдущих примерах явно указывается тип переменной. Можно также разрешить компилятору определить тип переменной из его выражения инициализации. Для этого используйте var ключевое слово вместо имени типа. Дополнительные сведения см. в разделе неявно типизированных локальных переменных .

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

const string Greeting = "Hello"; const double MinLimit = -10.0, MaxLimit = -MinLimit; 

При объявлении локальной константы необходимо также инициализировать ее.

Сведения о локальных ссылочных переменных см. в разделе «Эталонные переменные «.

Неявно типизированные локальные переменные

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

var greeting = "Hello"; Console.WriteLine(greeting.GetType()); // output: System.String var a = 32; Console.WriteLine(a.GetType()); // output: System.Int32 var xs = new List(); Console.WriteLine(xs.GetType()); // output: System.Collections.Generic.List`1[System.Double] 

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

Обычно используется выражение var вызова конструктора. Использование var позволяет вам не повторять имя типа при объявлении переменной и создании экземпляра объекта, как показано в следующем примере:

var xs = new List(); 

Вы можете использовать целевое типизированное new выражение в качестве альтернативы:

List xs = new(); List? ys = new(); 

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

var fromPhoenix = from cust in customers where cust.City == "Phoenix" select new < cust.Name, cust.Phone >; foreach (var customer in fromPhoenix) < Console.WriteLine($"Name=, Phone="); > 

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

При сопоставлении шаблонов в шаблоне var используется ключевое слово var .

Ссылочные переменные

При объявлении локальной переменной и добавлении ref ключевое слово перед типом переменной объявляется эталонная переменная или локальная ref :

ref int alias = ref variable; 

Ссылочная переменная — это переменная, которая ссылается на другую переменную, которая называется ссылочной. То есть ссылочная переменная является псевдонимом его ссылки. При назначении значения ссылочной переменной это значение назначается референту. При чтении значения ссылочной переменной возвращается значение ссылки. В следующем примере продемонстрировано такое поведение.

int a = 1; ref int alias = ref a; Console.WriteLine($"(a, alias) is (, )"); // output: (a, alias) is (1, 1) a = 2; Console.WriteLine($"(a, alias) is (, )"); // output: (a, alias) is (2, 2) alias = 3; Console.WriteLine($"(a, alias) is (, )"); // output: (a, alias) is (3, 3) 

ref Используйте оператор = ref назначения для изменения ссылочной переменной, как показано в следующем примере:

void Display(int[] s) => Console.WriteLine(string.Join(" ", s)); int[] xs = [0, 0, 0]; Display(xs); ref int element = ref xs[0]; element = 1; Display(xs); element = ref xs[^1]; element = 3; Display(xs); // Output: // 0 0 0 // 1 0 0 // 1 0 3 

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

Можно определить локальную ref readonly переменную. Нельзя назначить значение переменной ref readonly . Однако можно ref переназначить такую эталонную переменную, как показано в следующем примере:

int[] xs = [1, 2, 3]; ref readonly int element = ref xs[0]; // element = 100; error CS0131: The left-hand side of an assignment must be a variable, property or indexer Console.WriteLine(element); // output: 1 element = ref xs[^1]; Console.WriteLine(element); // output: 3 

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

using System; public class NumberStore < private readonly int[] numbers = [1, 30, 7, 1557, 381, 63, 1027, 2550, 511, 1023]; public ref int GetReferenceToMax() < ref int max = ref numbers[0]; for (int i = 1; i < numbers.Length; i++) < if (numbers[i] >max) < max = ref numbers[i]; >> return ref max; > public override string ToString() => string.Join(" ", numbers); > public static class ReferenceReturnExample < public static void Run() < var store = new NumberStore(); Console.WriteLine($"Original sequence: "); ref int max = ref store.GetReferenceToMax(); max = 0; Console.WriteLine($"Updated sequence: "); // Output: // Original sequence: 1 30 7 1557 381 63 1027 2550 511 1023 // Updated sequence: 1 30 7 1557 381 63 1027 0 511 1023 > > 

В предыдущем примере GetReferenceToMax метод является методом возвращается по ссылке . Он не возвращает максимальное значение, но возвращаемое ссылкой, которое является псевдонимом элемента массива, который содержит максимальное значение. Метод Run назначает ссылку возвращаемой переменной max . Затем, назначив max его, он обновляет внутреннее хранилище экземпляра store . Можно также определить ref readonly метод. Вызывающие методы ref readonly не могут назначить значение возвращаемой ссылке.

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

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

Сведения о ref полях см ref . в разделе полей статьи ref типов структур.

область d ref

Контекстная ключевое слово scoped ограничивает время существования значения. Модификатор scoped ограничивает время существования ref-safe-to-escape или safe-to-escape соответственно текущим методом. Фактически добавление модификатора утверждает, scoped что код не будет расширять время существования переменной.

Можно применить scoped к параметру или локальной переменной. Модификатор scoped может применяться к параметрам и локальным параметрам, если тип является типом ref struct . scoped В противном случае модификатор может применяться только к локальным ссылочным переменным. Это включает локальные переменные, объявленные модификатором ref и параметрами, объявленными с in ref помощью модификаторов или out модификаторов.

Модификатор scoped неявно this добавляется в методы, объявленные в struct параметрах out , параметрах и ref параметрах, когда тип является ref struct .

Спецификация языка C#

Дополнительные сведения см. в следующих разделах статьи Спецификация языка C#:

• Инструкции объявления
• Ссылочные переменные и возвращается

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

См. также

• справочник по C#
• Инициализаторы объектов и коллекций
• Ключевое слово ref
• Сокращение выделения памяти с помощью новых функций C#
• Параметры var (правила стиля IDE0007 и IDE0008)

Совместная работа с нами на GitHub

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

Переменные

Теги: Си переменные. char, int, unsigned, long, long long, float, double, long double, long float, lexical scoping. Объявление переменных. Область видимости. Инициализация переменных. Имена переменных. Экспоненциальная форма.

Переменные

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

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

Например, правильные идентификаторы
a, _, _1_, Sarkasm, a_long_variable, aLongVariable, var19, defaultX, char_type
неверные
1a, $value, a-long-value, short

Си — регистрозависимый язык. Переменные с именами a и A, или end и END, или perfectDark и PerfectDarK – это различные переменные.

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

• 1) Размер переменной в байтах (сколько байт памяти выделит компьютер для хранения значения)
• 2) Представление переменной в памяти (как в двоичном виде будут расположены биты в выделенной области памяти).

Целые

• char — размер 1 байт. Всегда! Это нужно запомнить.
• short — размер 2 байта
• int — размер 4 байта
• long — размер 4 байта
• long long — размер 8 байт.

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

Теперь давайте определим максимальное и минимальное число, которое может хранить переменная каждого из типов. Числа могут быть как положительными, так и отрицательными. Отрицательные числа используют один бит для хранения знака. Иногда знак необходим (например, храним счёт в банке, температуру, координату и т.д.), а иногда в нём нет необходимости (вес, размер массива, возраст человека и т.д.). Для этого в си используется модификатор типа signed и unsigned. unsigned char — все 8 бит под число, итого имеем набор чисел от 00000000 до 11111111 в двоичном виде, то есть от 0 до 255 signed char от -128 до 128. В си переменные по умолчанию со знаком. Поэтому запись char и signed char эквивалентны.

Таб. 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(тип). Это именно оператор, потому что функция не имеет возможности получить информацию о размере типов во время выполнения приложения. Напишем небольшую программу чтобы удостовериться в размерах переменных.

#include #include int main() < char c; short s; int i; long l; long long L; //Вызов sizeof как "функции" printf("sizeof(char) = %d\n", sizeof(c)); printf("sizeof(short) = %d\n", sizeof(s)); printf("sizeof(int) = %d\n", sizeof(i)); printf("sizeof(long) = %d\n", sizeof(l)); printf("sizeof(long long) = %d\n", sizeof(L)); //Вызов как оператора printf("sizeof(char) = %d\n", sizeof c); printf("sizeof(short) = %d\n", sizeof s); printf("sizeof(int) = %d\n", sizeof i); printf("sizeof(long) = %d\n", sizeof l); printf("sizeof(long long) = %d\n", sizeof L); _getch(); >

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

#include #include int main() < printf("sizeof(char) = %d\n", sizeof(char)); printf("sizeof(short) = %d\n", sizeof(short)); printf("sizeof(int) = %d\n", sizeof(int)); printf("sizeof(long) = %d\n", sizeof(long)); printf("sizeof(long long) = %d\n", sizeof(long long)); //нельзя произвести вызов sizeof как оператора для имени типа //sizeof int - ошибка компиляции _getch(); >

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

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

• float — 4 байта,
• long float — 8 байт
• double — 8 байт
• long double — 8 байт.

Таб. 2 Размер типов с плавающей точкой в си.

Тип	Размер, байт	Количество значащих знаков мантиссы	Минимальное значение	Максимальное значение
float	4	6-7	1.175494351 E – 38	3.402823466 E + 38
double	8	15-16	2.2250738585072014 E – 308	1.7976931348623158 E + 308

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

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

#include #include void main() < unsigned a = 4294967295; int b = 2147483647; //Переполнение беззнакового типа printf("%u\n", a); a += 1; printf("%u", a); //Переполнение знакового типа printf("%d\n", b); b += 1; printf("%d", b); getch(); >

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

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

• 11 — число типа int
• 10u — unsigned
• 22l или 22L — long
• 3890ll или 3890LL — long long (а также lL или Ll)
• 80.0f или 80.f или 80.0F — float (обязательно наличие десятичной точки в записи)
• 3.0 — число типа double

#include #include int main()

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

int a = 10u; double g = 3.f;

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

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

#include #include void main()

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

Э кспоненциальной формой представления числа называют представление числа в виде M e ± p , где M — мантиса числа, p — степень десяти. При этом у мантисы должен быть один ненулевой знак перед десятичной запятой.
Например 1.25 === 1.25e0, 123.5 === 1.235e2, 0.0002341 === 2.341e-4 и т.д.
Представления 3.2435e7 эквивалентно 3.2435e+7
Существеут и другое представление («инженерное»), в котором степень должна быть кратной тройке. Например 1.25 === 1.25e0, 123.5 === 123.5e0, 0.0002341 === 234.1e-6, 0.25873256 === 258.73256e-3 и т.д.

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

В си переменные объявляются всегда в начале блока (блок — участок кода ,ограниченный фигурными скобками)

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

int a; double parameter;

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

long long arg1, arg2, arg3;

#include #include int main() < int a = 10; int b; while (a>0) < int z = a*a; b += z; >>

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

int main()

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

int main()

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

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

#include #include int main()

Если выполнять эту программу на VC, то во время выполнения вылетит предупреждение
Run-Time Check Failure #3 — The variable ‘i’ is being used without being initialized.
Если нажать «Продолжить», то программа выведет «мусор». В многих других компиляторах при выполнении программы не будет предупреждения.

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

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

#include #include int global = 100; void foo() < printf("foo: %d\n", global); >void bar(int global) < printf("bar: %d\n", global); >int main()

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

#include #include int global = 100; int main()

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

#include #include int global = 100; int main() < int x = 10; < int y = 30; printf("%d", x); >printf("%d", y); >

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

#include #include int global = 100; int main() < int x = 10; < int x = 20; < int x = 30; printf("%d\n", x); >printf("%d\n", x); > printf("%d\n", x); getch(); >

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

• 1) Разрабатывается несколькими людьми и состоит из сотен тысяч строк кода
• 2) Работает в несколько потоков

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

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

ru-Cyrl 18- tutorial Sypachev S.S. 1989-04-14 sypachev_s_s@mail.ru Stepan Sypachev students

Всё ещё не понятно? – пиши вопросы на ящик

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

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

Объявление переменной

тип список_идентификаторов_переменных;

Список идентификаторов может состоять из идентификаторов переменных, разделенных запятыми. Например:

int x1, x2;

Одновременно с объявлением некоторые или все переменные могут быть инициализированы. Например:

int x1 = 1, x2 = 2;

Для инициализации можно использовать не только константы, но и произвольные выражения, содержащие объявленные ранее константы и переменные. Например:

int x1 = 1, x2 = 2*x1;

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

for (int i = 0; i < 10; i++)

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

int a; // объявление переменной a целого типа. float b; // объявление переменной b типа данных с плавающей запятой. double c = 14.2; // инициализация переменной типа double. char d = 's'; // инициализация переменной типа char. bool k = true; // инициализация логической переменной k.

Замечания

• В C++ оператор присваивания (=) – не является знаком равенства и не может использоваться для сравнения значений. Оператор равенства записывается как «двойное равно» (==).
• Присваивание используется для сохранения определенного значение в переменной.

Как ввести переменную в с

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

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

тип_переменной имя_переменной;

Именование переменных

Имя переменной последовательность алфавитных-цифровых символов и знака подчеркивания _. При этом имя переменной должно начинаться с алфавитного символа или подчеркивания.

Кроме того, в качестве имени переменной нельзя использовать ключевые слова языке C++, например, for или if . Но таких слов не так много, и по ходу освоения C++ вы соориентируетесь, какие слова являются ключевыми.

Следует отметить, что при этом не рекомендуются следующие именования:

• имена, которые начинаются с двух подчеркиваний
• имена, которые начинаются с подчеркивания, за которым идет заглавный алфавитный символ
• имена в глобальной области (вне функции main), которые начинаются с подчеркивания

Дело в том, что при подобных именах повышается вероятность, что подобные названия будут конфликтовать с именами (например, именами переменных), которые генерирует компилятор или которые определены в подключаемых стандартных модулях C++. Поэтому некоторые вообще не рекомендуют начинать имя с символа подчеркивания

Определение переменной

В общем случае переменная определяется в следующем виде:

тип_переменной имя_переменной;

Например, простейшее определение переменной:

int age;

Здесь определена переменная age, которая имеет тип int . Поскольку определение переменной представляет собой инструкцию, то после него ставится точка с запятой.

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

int age; int Age;

Поэтому переменная Age не будет представлять то же самое, что и переменная age.

Также нельзя объявить больше одной переменной с одним и тем же именем, например:

int age; int age;

Подобное определение вызовет ошибку на этапе компиляции.

Инициализация

После определения переменной можно присвоить некоторое значение. Присвоение переменной начального значения называется инициализацией . В C++ есть три вида инициализации:

• Нотация присваивания (assignment notation)
• Функциональная нотация (functional notation)
• Инициализация в фигурных скобках (braced initialization)

Рассмотрим все эти виды инициализаций

Нотация присваивания

Суть нотациия присваивания - с помощью оператора присваивания (знак "равно" или =) переменной передаем некоторое значение:

int age; age = 20;

Здесь в качестве значения переменной присваивается число 20. Постоянные значения любого типа, наподобие чисел, символов, строк, такие как 20, 123.456 (дробное число), "A" или "hello", называются литералами . То есть в данном случае переменной присваивается целочисленный литерал 20.

Например, определим в программе переменную и выведем ее значение на консоль:

#include int main() < int age; age = 28; std::cout можно вывести несколько значений на консоль.
 
После компиляции и запуска скомпилированной программы на консоль будет выведено число 28.
 
Age = 28
Можно сразу при определении переменной дать ей некоторое начальное значение:
#include int main() < int age = 28; std::coutint age ; // braced initialization
В данном случае переменная будет иметь значение 38.
Функциональная нотация
При функциональной нотации после названия переменной в круглых скобках указывается ее значение:
int age (38); // functional notation
В данном случае переменная будет иметь значение 38.
Во всех трех случаях присваиваемое переменной значение может представлять сложное вычисляемое выражение. Например:
int age1 ; int age2 (22 + 5); int age3 = 22 + 5;
Можно сразу инициализировать несколько переменных:
int age1 , age2 (23), age3 = 24;
В большинстве случаев все три варианта инициализации эквивалентны. Однако инициализация в фигурных скобках немного безопаснее, когда применяется сужающее преобразование. В общем случае ожидается, что переменной передается значение, которое соответствует ее типу. Если же это не так, то компилятор попытается преобразовать присваиваемое значение в тип переменной. Сужающее преобразование изменяет значение одного типа на тип с более ограниченным диапазоном значений. Таким образом, преобразование может привести к потере информации. Возьмем следующий пример:
#include int main()
Здесь переменным age1 и age2, которые представляют тип int , то есть целое число, присваивается дробное значение - 23.5 и 24.5 соответственно. Но в большинстве компиляторов, по крайней мере на момент написания данной статьи, этот код нормально скомпилируется и выполнится. Мы получим следующий вывод:
Age1 = 23 Age2 = 24
Теперь возьмем пример с инициализацией через фигурные скобки:
#include int main() < int age ; std::cout


Здесь переменной age, которая также представляет целое число, также присваивается дробное значение - 22.5. Однако теперь при компиляции многие компиляторы сообщат нам об ошибке. Например, вывод компилятора g++:
hello.cpp: In function 'int main()': hello.cpp:5:15: error: narrowing conversion of '2.25e+1' from 'double' to 'int' [-Wnarrowing] 5 | int age1 ;
Следует отметить, что некоторые компиляторы могут все таки скомпилировать данный код, однако все равно отобразят предупреждение.
Инициализация нулем
При инициализации в фигурных скобках можно опустить значение:
int counter <>;
В этом случае переменная будет инициализироваться нулем и фактически будет аналогично коду:
int counter ;
Инициализация по умолчанию
Если переменную не инициализировать, то происходит ее инициализация по умолчанию. И переменная получает некоторое значение по умолчанию, которое зависит от места, где эта переменная определена.
Если переменная, которая представляет встроенный тип (например, тип int), определена внутри функции, то она получает неопределенное значение. Если переменная встроенного типа определена вне функции, то она получает то значение по умолчанию, которое соответствует ее типу. Для числовых типов это число 0. Например:
#include int x; int main() < int y; std::cout  
X = 0 Y = 0
А в Visual Studio отсутствие значения переменной y вызовет ошибку компиляции.
Но в любом случае перед использованием переменной лучше явным образом назначать ей определенное значение, а не полагаться на значение по умолчанию.
Изменение значения
Ключевой особенностью переменных является то, что мы можем изменять их значения:
#include int main()
Консольный вывод программы:
Age1 = 22 Age2 = 23 Age3 = 38


Похожие публикации:

11 сколько различных решений имеет система уравнений
Python как загрузить матрицу из файла
Адресная строка браузера что это такое
Как построить ромб по двум диагоналям