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

Инициализация переменной – это присваивание переменной значения, которое в дальнейшем она, переменная, будет хранить, и которое можно будет использовать, путем обращения к имени переменной.

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

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

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

Примеры объявления переменных (без инициализации!):

int x;

String string1;

int x1, x2, x3;

char znak;

double inputValue;

Примеры объявления переменной с последующей отдельной(!) инициализацией:

int x;

x=-6;

String string1;

int x1, x2, x3;

string1="Yes";

char znak;

x1=6, x2=0;

double inputValue;

inputValue=5.76, x3=8;

znak=’7′;

Примеры объявления переменной с одновременной инициализацией – то есть когда и объявление, и инициализация выполняются в одной строке кода:

int x=5;

String string1="no, no, no. ";

int x1=7, x2, x3=-678;

Примеры объявления переменной с инициализацией через дополнительные возможности языка Java – в частности, через использование правила "сначала вычисли значение – а потом присвой его переменной":

int x1=6, x2, x3;

x2=10+x2;

x3=-x2;

Следует отметить, что возможны и более «экзотические» инициализации типа:

x1=x2=x3=0;

x1=x2=x3=in.nextInt();

На наш взгляд, не следует увлекаться подобными «сокращениями», особенно на первом этапе знакомства и освоения языка Java.

Очень важно обратить внимание на специфику инициализации переменных типа char и String (напомним, что эти типы являются нечисловыми):

· Переменные типа char инициализируются значениями, заключенными между двумя знаками "апостроф"

· Переменные типа String инициализируются значениями, заключенными между двумя знаками "кавычки".

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

Мы не сомневаемся, что каждому будет понятно и без особых дополнительных объяснений, по каким правилам можно использовать математические операторы "сложение" (+), "вычитание" (-), "умножение" (*).

Но ни в коем случае не спешите использовать оператор "деление" (/) – дело в том, что это действие в языке Java принципиально отличается от принятого в математике!

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

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

Приведем несколько примеров объявления переменных – с пояснениями, какие из них правильные, а какие – ошибочные.

Объявление переменных Варианты ответа ученика
int x; Нет ошибок
double a,b,c; Нет ошибок
int a,a; Ошибка: дважды используется одно и то же имя переменной
Int a,b; Ошибка: тип переменной указан с большой буквой (правильно – int).
int a, A; Нет ошибки в имени – большая и маленькая буквы считаются разнымипеременными (хотя это – крайне нежелательно!)
String kukla1; kukla2; Ошибка: при перечислении имен в списке используется разделительный знак "запятая" (,), а не знак "точка с запятой" (;)
char znak1,znak2,znak_1; Нет ошибок
int x, a, b; double y ,z, x; Ошибка: одно и то же имя (х) используется дважды в объявлении переменных
int x; double X; Нет ошибок
Читайте также:  Как писать повторяющиеся слова

И еще примеры объявления переменных вместе с их инициализацией – с указанием, какие из них правильные, а какие – ошибочные; и тоже – с обоснованием ответов.

Объявление и инициализация переменных Варианты ответа ученика
int x; x=6; Нет ошибок
int a=6, b=2.5; Ошибка: переменная типа "простое целое" получает значение десятичной дроби.
int b=3; double c; c=5; Нет ошибок
int a,b,c=5; b=5; a=-b; Нет ошибок
double a=3.6,b; int b=4; Ошибка: используется дважды имя переменной.

А вот пример "обратного подхода": даны словесные описания объявления и инициализации переменных, которые затем записаны в правилах языка Java – причем в разных допустимых вариантах.

Словесное описание Варианты ответа ученика
Переменная х (типа "простое целое") получает значение 16 int x; x=16; int x=16;
Переменные х и t относятся к типу "простое целое", при этом значение переменной х равно -2 int x,t; x=-2; int x=-2,t; int t, x=-2;

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

Пример первый: напишите класс, который будет присваивать значения 5 и 9 двум переменных, а затем третья переменная будет получать значение, равное сумме значений первых двух переменных.

Не нашли то, что искали? Воспользуйтесь поиском:

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

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

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

float balance = 123.23;

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

Переменные

П еременные используются для хранения значений (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_ и пр.

Например, правильные идентификаторы
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 255
signed char
( char )
1 -128 127
unsigned short 2 65535
signed short
( short )
2 -32768 32767
unsigned int
( unsigned )
4 4294967296
signed int
( int )
4 -2147483648 2147483647
unsigned long 4 4294967296
signed long
( long )
4 -2147483648 2147483647
unsigned long long 8 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

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

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

Здесь также приведены значения для VC2012, по стандарту размер типов float Таб. 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 в конце концов мы "сбросим значение"

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

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

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

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

Экспоненциальная форма записи также по умолчанию обозначает число типа double.

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

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

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

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

Э кспоненциальной формой представления числа называют представление числа в виде 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 и т.д.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Adblock detector