Переменные

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



Переменные

Переменные используются для хранения значений (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 байт.
Здесь следует сделать замечание. Размер переменных в си не определён явно, как размер в байтах. В стандарте только указано, что

char <= short <= int <= long <= long long

Указанные выше значения характерны для компилятора 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<conio.h>
#include<stdio.h>

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<conio.h>
#include<stdio.h>

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 байт.
Здесь также приведены значения для VC2012, по стандарту размер типов float <= long float <= double <= long double все числа с плавающей точкой - со знаком.
Таб. 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 <conio.h>
#include <stdio.h>

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
Экспоненциальная форма записи также по умолчанию обозначает число типа double. 

#include<conio.h>
#include<stdio.h>

int main() {

	printf("sizeof(int) = %d\n", sizeof(10));
	printf("sizeof(unigned) = %d\n", sizeof(10u));
	printf("sizeof(long) = %d\n", sizeof(10l));
	printf("sizeof(long long) = %d\n", sizeof(10ll));
	printf("sizeof(float) = %d\n", sizeof(10.f));
	printf("sizeof(double) = %d\n", sizeof(10.));
	printf("sizeof(double) = %d\n", sizeof(10e2));

	getch();
}

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

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

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

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

#include<conio.h>
#include<stdio.h>

void main() {
	int x = 0xFF;
	int y = 077;
	printf("hex x = %x\n", x);
	printf("dec x = %d\n", x);
	printf("oct x = %o\n", x);
	printf("oct y = %o\n", y);
	printf("dec y = %d\n", y);
	printf("hex y = %x", y);
	getch();
}

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

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

int main() {
	int a = 10;
	int b;
	while (a>0){
		int z = a*a;
		b += z;
	}
}

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

int main() {

	int i;
	i = 10;
	int j;
}

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

int main() {

	int i = 10;
	int j;
}

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

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

#include<conio.h>
#include<stdio.h>

int main() {
	int i;
	printf("%d", i);
	getch();
}

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

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

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

#include<conio.h>
#include<stdio.h>

int global = 100;

void foo() {
	printf("foo: %d\n", global);
}

void bar(int global) {
	printf("bar: %d\n", global);
}

int main() {
	foo();
	bar(333);
	getch();
}

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

#include<conio.h>
#include<stdio.h>

int global = 100;

int main() {
	int global = 555;
	printf("%d\n", global);
	getch();
}

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

#include<conio.h>
#include<stdio.h>

int global = 100;

int main() {
	int x = 10;
	{
		int y = 30;
		printf("%d", x);
	}
	printf("%d", y);
}

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

#include<conio.h>
#include<stdio.h>

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) Работает в несколько потоков

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

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

Q&A

Всё ещё не понятно? – пиши вопросы на ящик email
Пишем первую программу (Linux)
Оператор присваивания