Переменные в языке Си. Объявление переменной в Си. Типы данных и операции в языке си. выражения

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

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

Описание состоит из спецификатора типа и следующего за ним списка переменных. Переменные в списке разделяются запятыми. В конце описания ставится точка с запятой.

Примерыописаний:

char a,b; /* Переменные а и b имеют тип

char */ intх; /* Переменная х - типа int

*/ char sym; /" Описаны переменные sym типа char;

*/ int count.num; /* num и count типа int */

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

Примеры: char backch = "\0";

Рассмотрим основные типы в языке Си.

int - целый ("integer"). Значения этого типа - целые числа из некоторого ограниченного диапазона (обычно от- 32768 до 32767). Диапазон определяется размером ячейки для типа и зависит от конкретного компьютера. Кроме того, имеются служебные слова, которые можно использовать с типом int: short int («short integer» - «короткое целое»), unsigned int («unsigned integer» - «целое без знака»), long int («длинное целое»), которые сокращают или, наоборот, расширяют диапазон представления чисел.

char - символьный («character»). Допустимое значение для этоготипа - одинсимвол (не путать с текстом!). Символ записывается в апострофах.

Примеры: "х"2"?"

В памяти компьютера символ занимает один байт. Фактически хранится не символ, а число - код символа (от 0 до 255). В специальных таблицах кодировки указываются все допустимые символы и соответствующие им коды.

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

float - вещественный (с плавающей точкой). Значения этого типа - числа, но, в отличии от char и int, не обязательно целые.

12.87 -316.12 -3.345е5 12.345e-15

double - вещественные числа двойной точности. Этот тип аналогичен типу float, но имеет значительно больший диапазон значений (например, для системы программирования Borland-C от 1.7Е-308 до 1.7Е+308 вместо диапазона от 3.4Е-38 до 3.4Е+38 для типа float). Однако увеличение диапазона и точности представления чисел ведет к снижению скорости выполнения программ и неэкономному использованию оперативной памяти компьютера.

Обратите внимание на отсутствие в этом списке строкового типа. В языке Си нет специального типа, который можно было бы использовать для описания строк. Вместо этого строки представляются в виде массива элементов типа char. Это означает, что символы в строке будут располагаться в соседних ячейках памяти.

Необходимо отметить, что последним элементом массива является символ \0. Это «нуль-символ», и в языке Си он используется для того, чтобы отмечать конец строки. Нуль-символ не цифра 0; он не выводится на печать и в таблице кодов ASCII имеет номер 0. Наличие нуль-символа означает, что количество ячеек массива должно быть. по крайней мере, на одну больше,чем число символов, которые необходимо размещать в памяти.

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

Программа 84

# include main()

scanf("%s",string) ;

printf("%s",string);

В этом примере описан массив из 31 ячейки памяти, в 30 из которых можно поместить один элемент типа char. Он вводится при вызове функции scanf("%s",string); "&"отсутствует при указании массива символов.

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

Например, &name - указатель на переменную name;

Здесь & - операция получения адреса. Фактический адрес - это число, а символическое представление адреса &name является константой типа «указатель».

В языке Си имеются и переменные типа указатель. Точно так же, как значением переменной типа char является символ, а значением переменной типа int - целое число, значением переменной типа указатель служит адрес некоторой величины.

Если мы дадим указателю имя ptr, то сможем написать такой оператор:

ptr = &name;/* присваивает адрес name переменной ptr */

Мы говорим в этом случае, что prt «указатель на» name. Различие между двумя формами записи: ptr и &name - в том, что prt - это переменная, в то время как &name - константа. В случае необходимости можно сделать так, чтобы переменная ptr указывала на какой-нибудь другой объект:

ptr = &bah; /* ptr указывает на bah, а не на name */

Теперь значением переменной prt является адрес переменной bah. Предположим, мы знаем, что в переменной ptr содержится ссылка на переменную bah. Тогда для доступа к значению этой переменной можно воспользоваться операцией «косвенной адресации» * :

val = *ptr; /* определение значения, на которое указывает ptr */ Последние два оператора, взятые вместе, эквивалентны следующему:

Итак, когда за знаком & следует имя переменной, результатом операции является адрес указанной переменной; &nurse дает адрес переменной nurse; когда за знаком * следует указатель на переменную, результатом операции является величина, помещенная в ячейку памяти с указанным адресом.

Пример: nurse = 22;

ptr = &nuse; /* указатель на nurse */

Результат- присваивание значения 22 переменной val.

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

Примеры правильного описания указателей: int *pi; char *pc;

Спецификация типа задает тип переменной, на которую ссылается указатель, а символ * определяет саму переменную как указатель. Описание вида int *pi; говорит, что pi - это указатель и что *pi - величина типа int.

В языке Си предусмотрена возможность определения имен типов данных. Любому типу данных с помощью определения typedef можно присвоить имя и использовать это имя в дальнейшем при описании объектов.

Формат: typedef <старый тип> <новый тип> Пример: typedef long LARGE; /* определяется тип large, эквивалентный типу long */

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

Операции. Язык Си отличается большим разнообразием операций (более 40). Здесь мы рассмотрим лишь основные из них, табл. 3.3.

Арифметические операции . К ним относят

Сложение(+),

Вычитание (бинарное) (-),

Умножение (*),

Деление (/),

Остаток от деления нацело (%),

Вычитание (унарное) (-) .

В языке Си принято правило: если делимое и делитель имеют тип int, то деление производится нацело, т е. дробная часть результата отбрасывается.

Как обычно, в выражениях операции умножения, деления и нахождения остатка выполняются раньше сложения и вычитания. Для изменения порядка действий используют скобки.

Программа 85

#include

5 = -3 + 4 * 5 - 6; printf("%d\n",s);

s = -3 + 4%5 - 6; printf("%d\n",s);

s = -3 * 4% - 6/5; printf("%d\n",s);

s= (7 + 6)%5/2; printf("%d\n",s);

Результат выполнения программы: 11 1 0 1

Таблица 3.3 Старшинство и порядок выполнения операций

Теги: С++ типы данных, auto, decltype, автоматический вывод типов

Типы данных

К ак и в си, переменные в С++ должны иметь валидное имя. То есть, состоять из чисел, букв и знака подчёркивания, не должны начинаться с цифры и не должны совпадать со служебными словами, которых теперь стало больше

alignas	alignof	and	and_eq
asm	auto	bitand	bitor
bool	break	case	catch
char	char16_t	char32_t	class
compl	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	mutable	namespace	new
noexcept	not	not_eq	nullptr
operator	or	or_eq	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	xor	xor_eq

Как и си, С++ регистрозависимый язык.

Основные типы данных

Б азовые типы данных в C++ можно разбить на несколько групп

Знаковый тип. Переменные знакового типа могут использоваться для хранения одного символа. Самый простой тип char, размер которого равен 1 байт. Также имеются типы для представления знаков, размером больше одного байта

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

Целочисленные типы данных. Как и в си, могут обладать модификаторами signed и unsigned. Как и в си, основными типами являются char, int, long и long long. Ничего нового здесь не появилось.

Числа с плавающей точкой. Представлены типами float, double и long double. Ничего нового по сравнению с си.

Все описанные выше типы называют также арифметическими. Кроме них существует ещё пустой тип – void (также ничего нового по сравнению с си) и нулевой указатель. Теперь, вместо NULL с его удивительными свойствами, появился новый фундаментальный тип nullptr_t с единственным значением nullptr, который хранит нулевой указатель и равен только сам себе. При этом, он может быть приведён к нулевому указателю нужного типа.

В си++ введён булев тип. Он хранит всего два возможных значения true и false.

Си++ поддерживает также множество составных типов данных, которые будут рассмотрены позднее.

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

В С++ переменные могут быть объявлены в любом месте внутри функции, а не только в самом начале блока кода В том числе, переменные могут быть объявлены и внутри цикла for.

Float a; float b; float sum; float step; a = 3.0f; b = 4.3f; sum = 0.0f; step = 0.05f; for (float i = a; i < b; i += step) { sum += i * i; } float mid = sum / (b - a) / step;

Инициализировать переменные можно при создании как в си

Int x = 0;

либо, используя конструктор

Int x(0); double d(3.2);

Кроме того, в С++ 2011 появилась т.н. uniform initialization, универсальная инициализация, которая позволяет использовать один синтаксис для инициализации любых объектов

Struct Point { int x; int y; }; struct Point position = { 3, 4 }; Point *pt = new Point{6, 8}; int length{5};

Вывод типов

В си++ 2011 служебное слово auto используется для автоматического определения типа переменных. Часто тип переменной может быть определён, исходя из правой части инициализации. В том случае, когда компилятор может однозначно определить тип, его можно задавать с помощью служебного слова auto:

Auto x = 3; //эквивалентно int x = 3; auto point = new Point; //эквивалентно Point *point = new Point

Кроме этого, есть возможность задавать тип переменной по уже имеющемуся типу, с помощью служебного слова decltype

Int intX = 42; decltype(intX) intY = 33; //эквивалентно int intY = 33; auto pt1 = new Point; decltype(pt1) p2 = new Point{2, 6}; //эквивалентно //Point *pt1 = new Point; //Point *pt2 = new Point{2, 6}

Строки

В С++ нет базового типа строка. Однако есть стандартная библиотека string, которая предоставляет класс для работы со строками.

#include #include void main() { std::string first_name = "Vasya"; std::string last_name = { "Pupkin" }; //конкатенация строк auto full_name = first_name + " " + last_name; std::string *department = new std::string("Department of copying and scanning"); std::cout << full_name << std::endl; //сравнение строк std::string a = "A"; std::string b = "B"; if (first_name.compare(last_name) > 0) { std::cout << a + " > " + b << std::endl; } else { std::cout << a + " < " + b << std::endl; } //подстрока std::string subs = department->substr(0, 10); std::cout << subs << std::endl; //замена подстроки std::cout << last_name.replace(0, 1, "G") << std::endl; //вставка std::string new_department = department->insert(department->length(), " and shreddering"); std::cout << new_department << std::endl; delete department; system("pause"); }

Со стандартной библиотекой string познакомимся поздее более подробно.

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

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

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

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

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

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

В Си имеется 4 базовых типа:

char - символьный тип;

int - целый тип,

float - вещественный тип одинарной точности,

double - вещественный тип двойной точности.

Для задания производных типов используются квалификаторы :short (короткий) - используется с типомint ,long (длинный) - используется с типамиint иdouble ;signed (со знаком),unsigned (без знака) - применимы к любому целому типу. При отсутствии словаunsignedзначение считается знаковым,т. е. по умолчанию принятоsigned. В силу допустимости произвольного соединения квалификаторов и названий базовых типов один тип может иметь несколько обозначений. Сведения о стандартных типах Си представлены в таблицах 1 и 2. Через запятую в клетках первого столбца перечислены описатели-синонимы.

Таблица 1. Стандартные целые типы данных Си

Тип данных		Диапазон значений
char, signed char
unsigned int, unsigned
int, signed int, short int, short
		2147483648...2147483647

Интересно, что в Си тип charв зависимости от контекста может использоваться как символьный или как целый тип.

Таблица 2. Стандартные вещественные типы данных Си

Замечание. Для написания программ первой части пособия нам потребуются в основномдва типа: float и int .

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

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

Хорошим стилем является осмысленное именование переменных. Разрешается использовать строчные и прописные буквы, цифры и символ подчёркивания, который в Си считается буквой. Первым символом обязательно должна быть буква, в имени переменной не должно быть пробелов. В современных версиях компиляторов длина имени практически не ограничена. Имя переменной не может совпадать с зарезервированными ключевыми словами. Заглавные и строчные буквы в именах переменных различаются, переменные a и A - разные переменные.

Зарезервированные ключевые слова auto double int struct break else long switch register tupedef char extern return void case float unsigned default for signed union do if sizeof volatile continue enum short while
В языке Си все переменные должны быть объявлены. Это означает, что, во-первых, в начале каждой программы или функции Вы должны привести список всех используемых переменных, а во-вторых, указать тип каждой из них.

При объявлении переменной компилятор отводит ей место в памяти в зависимости от её типа. Стандартными средствами AVR GCC работает с типами данных char (символьный тип) и int (целочисленный тип).

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

Тип char

char - является самым экономным типом. Тип char может быть знаковым и беззнаковым. Обозначается, соответственно, как "signed char " (знаковый тип) и "unsigned char " (беззнаковый тип). Знаковый тип может хранить значения в диапазоне от -128 до +127. Беззнаковый - от 0 до 255. Под переменную типа char отводится 1 байт памяти (8 бит).

Ключевые слова (модификаторы) signed и unsigned указывают, как интерпретируется нулевой бит объявляемой переменной, т.е., если указано ключевое слово unsigned, то нулевой бит интерпретируется как часть числа, в противном случае нулевой бит интерпретируется как знаковый.

Тип int

Целочисленная величина int может быть short (короткой) или long (длинной).

Ключевое слово (модификатор) short ставится после ключевых слов signed или unsigned . Таким образом, различают следующие типы: signed short int, unsigned short int, signed long int, unsigned long int .

Переменная типа signed short int (знаковая короткая целая) может принимать значения от -32768 до +32767, unsigned short int (беззнаковая короткая целая) - от 0 до 65535. Под каждую из них отводится ровно по два байта памяти (16 бит).

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

Переменная unsigned short int может быть объявлена как unsigned int или unsigned short .

Под каждую величину signed long int или unsigned long int отводится 4 байта памяти (32 бита). Значения переменных этого типа могут находиться в интервалах от -2147483648 до 2147483647 и от 0 до 4294967295 соответственно.

Существуют также переменные типа long long int , для которых отводится 8 байт памяти (64 бита). Они также могут быть знаковыми и беззнаковыми. Для знакового типа диапазон значений лежит в пределах от -9223372036854775808 до 9223372036854775807, для беззнакового - от 0 до 18446744073709551615. Знаковый тип может быть объявлен и просто двумя ключевыми словами long long .

Тип	Диапазон	Шестнадцатиричный диапазон	Размер
unsigned char	0 ... 255	0x00 ... 0xFF	8 bit
signed char или просто char	-128 ... 127	-0x80 ... 0x7F	8 bit
unsigned short int или просто unsigned int или unsigned short	0 ... 65535	0x0000 ... 0xFFFF	16 bit
signed short int или signed int или просто short или int	-32768 ... 32767	0x8000 ... 0x7FFF	16 bit
unsigned long int или просто unsigned long	0 ... 4294967295	0x00000000 ... 0xFFFFFFFF	32 bit
signed long или просто long	-2147483648 ... 2147483647	0x80000000 ... 0x7FFFFFFF	32 bit
unsigned long long	0 ... 18446744073709551615	0x0000000000000000 ... 0xFFFFFFFFFFFFFFFF	64 bit
signed long long или просто long long	-9223372036854775808 ... 9223372036854775807	0x8000000000000000 ... 0x7FFFFFFFFFFFFFFF	64 bit

Переменные объявляют в операторе описания. Оператор описания состоит из спецификации типа и списка имён переменных, разделённых запятой. В конце обязательно должна стоять точка с запятой.

Объявление переменной имеет следующий формат:

[модификаторы] спецификатор_типа идентификатор [, идентификатор] ...

Модификаторы - ключевые слова signed , unsigned , short , long .
Спецификатор типа - ключевое слово char или int , определяющее тип объявляемой переменной.
Идентификатор - имя переменной.

Пример: char x; int a, b, c; unsigned long long y;
Таким образом, будут объявлены переменные x , a , b , c , y . В переменную x можно будет записывать значения от -128 до 127. В переменные a , b , c - от -32768 до +32767. В переменную y - от 0 до 18446744073709551615.

Инициализация значения переменной при объявлении

При объявлении переменную можно проинициализировать, то есть присвоить ей начальное значение. Сделать это можно следующим образом. int x = 100; Таким образом, в переменную x при объявлении сразу же будет записано число 100.

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

Константы

Переменная любого типа может быть объявлена как немодифицируемая. Это достигается добавлением ключевого слова const к спецификатору типа. Переменные с типом const представляют собой данные, используемые только для чтения, то есть этой переменной не может быть присвоено новое значение. Если после слова const отсутствует спецификатор типа, то константы рассматриваются как величины со знаком, и им присваивается тип int или long int в соответствии со значением константы: если константа меньше 32768, то ей присваивается тип int , в противном случае long int .

Пример: const long int k = 25; const m = -50; // подразумевается const int m=-50 const n = 100000; // подразумевается const long int n=100000

Присваивание

Для присваивания в Си служит знак "=". Выражение, стоящее справа от знака присваивания, вычисляется, и полученное значение присваивается переменной, стоящей слева от знака присваивания. При этом предыдущее значение, хранящееся в переменной, стирается и заменяется на новое.

Оператор "=" не следует понимать как равенство.
Например, выражение a = 5; следует читать как "присвоить переменной a значение 5".

Примеры: x = 5 + 3; // сложить значения 5 и 3, // результат присвоить переменной x (записать в переменную x) b = a + 4; // прибавить 4 к значению, хранящемуся в переменной a, // полученный результат присвоить переменной b (записать в переменную b) b = b + 2; // прибавить 2 к значению, хранящемуся в переменной b, // полученный результат присвоить переменной b (записать в переменную b)
В правой части значение переменной может использоваться несколько раз: c = b * b + 3 * b;

Пример: x = 3; // переменной x будет присвоено значение 3 y = x + 5; // к значению, хранящемуся в переменной x, будет прибавлено число 5, // полученный результат будет записан в переменную y z = x * y; // значения переменных x и y будут перемножены, // результат будет записан в переменную z z = z - 1; // от значения, хранящегося в переменной z, будет отнято 1 // результат будет записан в переменную z
Таким образом, в переменной z будет храниться число 23

Кроме простого оператора присваивания "=", в Си существует еще несколько комбинированных операторов присваивания: "+=", "-=", "*=
Примеры: x += y; // то же, что и x = x + y; - сложить x и y // и записать результат в переменную x x -= y; // то же, что и x = x - y; - отнять от x значение y // и записать результат в переменную x x *= y; // то же, что и x = x * y; - умножить x на y // и записать результат в переменную x x /= y; // то же, что и x = x / y; - разделить x на y // и записать результат в переменную x x %= y; // то же, что и x = x % y; // вычислить целочисленный остаток от деления x на y // и записать результат в переменную x

Инкремент и декремент

Если необходимо изменить значение переменной на 1, то используют инкремент или декремент .

Инкремент - операция увеличения значения, хранящегося в переменной, на 1.

Пример: x++; // значение переменной x будет увеличено на 1 $WinAVR = ($_GET["avr"]); if($WinAVR) include($WinAVR);?>
Декремент - операция уменьшения значения, хранящегося в переменной, на 1.

Пример: x--; // значение переменной x будет уменьшено на 1
Инкремент и декремент относятся к операциям присваивания. При использовании декремента и инкремента совместно с оператором присваивания "=" применяют постфиксную (x++) или префиксную (++x) запись. Первой выполняется префиксная запись.

Примеры: y = x++;
Предположим, что в переменной x хранилось значение 5. Тогда в y будет записано значение 5, после чего значение переменной x будет увеличено на 1. Таким образом, в y будет 5, а в x - 6. y = --x;
Если в x хранилось значение 5, то сначала будет выполнено уменьшение x до 4, а затем это значение будет присвоено переменной y . Таким образом, x и y будет присвоено значение 4.

Типом данных в программировании называют совокупность двух множеств: множество значений и множество операций, которые можно применять к ним. Например, к типу данных целых неотрицательных чисел, состоящего из конечного множества натуральных чисел, можно применить операции сложения (+), умножения (*), целочисленного деления (/), нахождения остатка (%) и вычитания (−).

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

• логический (bool);
• символьный (напр., char);
• целый (напр., int);
• с плавающей точкой (напр., float);
• перечисления (определяется программистом);
• void .

Поверх перечисленных строятся следующие типы:

• указательные (напр., int*);
• массивы (напр., char);
• ссылочные (напр., double&);
• другие структуры.

Перейдём к понятию литерала (напр., 1, 2.4F, 25e-4, ‘a’ и др.): литерал - запись в исходном коде программы, представляющаясобой фиксированное значение. Другими словами, литерал - это просто отображение объекта (значение) какого-либо типа в коде программы. В C++ есть возможность записи целочисленных значений, значений с плавающей точкой, символьных, булевых, строковых.

Литерал целого типа можно записать в:

• 10-й системе счисления. Например, 1205 ;
• 8-й системе счисления в формате 0 + число. Например, 0142 ;
• 16-й системе счисления в формате 0x + число. Например, 0x2F .

24, 030, 0x18 - это всё записи одного и того же числа в разных системах счисления.
Для записи чисел с плавающей точкой используют запись через точку: 0.1, .5, 4. - либо в
экспоненциальной записи - 25e-100. Пробелов в такой записи быть не должно.

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

Const int example = 3; // здесь const - спецификатор // int - базовый тип // example - имя переменной // = 3 - инициализатор.

Имя переменной является последовательностью символов из букв латинского алфавита (строчных и прописных), цифр и/или знака подчёркивания, однако первый символ цифрой быть не может . Имя переменной следует выбирать таким, чтобы всегда было легко догадаться о том, что она хранит, например, «monthPayment». В конспекте и на практиках мы будем использовать для правил записи переменных нотацию CamelCase. Имя переменной не может совпадать с зарезервированными в языке словами, примеры таких слов: if, while, function, goto, switch и др.

Декларатор кроме имени переменной может содержать дополнительные символы:

• * - указатель; перед именем;
• *const - константный указатель; перед именем;
• & - ссылка; перед именем;
• - массив; после имени;
• () - функция; после имени.

Инициализатор позволяет определить для переменной её значение сразу после объявления. Инициализатор начинается с литерала равенства (=) и далее происходит процесс задания значения переменной. Вообще говоря, знак равенства в C++ обозначает операцию присваивания; с её помощью можно задавать и изменять значение переменной. Для разных типов он может быть разным.

Спецификатор задаёт дополнительные атрибуты, отличные от типа. Приведённый в примере спецификатор const позволяет запретить последующее изменение значение переменной. Такие неизменяемые переменные называют константными или константой.

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

Const int EMPTY_CONST; // ошибка, не инициализована константная переменная const int EXAMPLE = 2; // константа со значением 2 EXAMPLE = 3; // ошибка, попытка присвоить значение константной переменной

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

Основные типы данных в C++

Разбирая каждый тип, читатель не должен забывать об определении типа данных.

1. Целочисленный тип (char, short (int), int, long (int), long long)

Из названия легко понять, что множество значений состоит из целых чисел. Также множество значений каждого из перечисленных типов может быть знаковым (signed) или беззнаковым (unsigned). Количество элементов, содержащееся в множестве, зависит от размера памяти, которая используется для хранения значения этого типа. Например, для переменной типа char отводится 1 байт памяти, поэтому всего элементов будет:

• 2 8N = 2 8 * 1 = 256, где N - размер памяти в байтах для хранения значения

В таком случае диапазоны доступных целых чисел следующие:

• - для беззнакового char
• [-128..127] - для знакового char

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

Unsigned long values; // задаёт целый (длинный) беззнаковый тип.

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

• 1 = размер char ≤ размер short ≤ размер int ≤ размер long.

Обычно размеры типов следующие: char - 1, short - 2, int - 4, long -8, long long - 8 байт.

Со значениями целого типа можно совершать арифметические операции: +, -, *, /, %; операции сравнения: ==, !=, <=, <, >, >=; битовые операции: &, |, xor, <<, >>.
Большинство операций, таких как сложение, умножение, вычитание и операции сравнения, не вызывают проблем в понимании. Иногда, после выполнения арифметических операций, результат может оказаться за пределами диапазона значений; в этом случае программа выдаст ошибку.
Целочисленное деление (/) находит целую часть от деления одного целого числа, на другое. Например:

• 6 / 4 = 1;
• 2 / 5 = 0;
• 8 / 2 = 4.

Символ процента (%) обозначает операцию определение остатка от деления двух целых чисел:

• 6 % 4 = 2;
• 10 % 3 = 1.

Более сложные для понимания операции - битовые: & (И), | (ИЛИ), xor (исключающее ИЛИ), << (побитовый сдвиг влево), >> (побитовый сдвиг вправо).

Битовые операции И, ИЛИ и XOR к каждому биту информации применяют соответствующую логическую операцию:

• 1 10 = 01 2
• 3 10 = 11 2
• 1 10 & 3 10 = 01 2 & 11 2 = 01 2
• 1 10 | 3 10 = 01 2 | 11 2 = 11 2
• 1 10 xor 3 10 = 01 2 xor 11 2 = 10 2

В обработке изображения используют 3 канала для цвета: красный, синий и зелёный - плюс прозрачность, которые хранятся в переменной типа int, т.к. каждый канал имеет диапазон значений от 0 до 255. В 16-иричной системе счисления некоторое значение записывается следующим образом: 0x180013FF; тогда значение 18 16 соответствует красному каналу, 00 16 - синему, 13 16 - зелёному, FF - альфа-каналу (прозрачности). Чтобы выделить из такого целого числа определённый канал используют т.н. маску, где на интересующих нас позициях стоят F 16 или 1 2 . Т.е., чтобы выделить значение синего канала необходимо использовать маску, т.е. побитовое И:

Int blue_channel = 0x180013FF & 0x00FF0000;

После чего полученное значение сдвигается вправо на необходимое число бит.

Побитовый сдвиг смещает влево или вправо на столько двоичных разрядов числа, сколько указано в правой части операции. Например, число 39 для типа char в двоичном виде записывается в следующем виде: 00100111. Тогда:

Char binaryExample = 39; // 00100111 char result = binaryExample << 2; // сдвигаем 2 бита влево, результат: 10011100

Если переменная беззнакового типа, тогда результатом будет число 156, для знакового оно равно -100. Отметим, что для знаковых целых типов единица в старшем разряде битового представления - признак отрицательности числа. При этом значение, в двоичном виде состоящие из всех единиц соответствует -1; если же 1 только в старшем разряде, а в остальных разрядах - нули, тогда такое число имеет минимальное для конкретного типа значения: для char это -128.

2. Тип с плавающей точкой (float, double (float))

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

Float value = 0.2; value == 0.2; // ошибка, value здесь не будет равно 0.2.

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

Value - 0.2 < 1e-6; // ok, подбирать интервал тоже нужно осторожно

Помимо операций сравнения тип с плавающей точкой поддерживает 4 арифметические операции, которые полностью соответствуют математическим операциям с вещественными числами.

3. Булевый (логический) тип (bool)

Состоит всего из двух значений: true (правда) и false (ложь). Для работы с переменными данного типа используют логические операции: ! (НЕ), == (равенство), != (неравенство), && (логическое И), || (логическое ИЛИ). Результат каждой операции можно найти в соответствующей таблицы истинности. например:

X Y XOR 0 0 0 0 1 1 1 0 1 1 1 0

4. Символьный тип (char, wchar_t)

Тип char - не только целый тип (обычно, такой тип называют byte), но и символьный, хранящий номер символа из таблицы символом ASCII . Например код 0x41 соответствует символу ‘A’, а 0x71 - ‘t’.

Иногда возникает необходимость использования символов, которые не закреплены в таблицы ASCII и поэтому требует для хранения более 1-го байта. Для них существует широкий символ (wchar_t).

5.1. Массивы

Массивы позволяют хранить последовательный набор однотипных элементов. Массив хранится в памяти непрерывным блоком, поэтому нельзя объявить массив, не указав его размер . Чтобы объявить массив после имени переменной пишут квадратные скобки () с указанием его размера. Например:

Int myArray; // Массив из 5-и элементов целого типа

Для инициализации массива значения перечисляют в фигурных скобках. Инициализировать таким образом можно только во время объявления переменной. Кстати, в этом случае необязательно указывать размер массива:

Int odds = {1, 3, 7, 9, 11}; // Массив инициализируется 5-ю значениями

Для доступа к определённому значению в массиве (элемента массива) используют операцию доступа по индексу () с указанием номера элемента (номера начинаются с 0). Например:

Odds; // доступ к первому элементу массива. Вернёт значение 1 odds; // доступ к третьему элементу. Вернёт значение 7 odds = 13; // 5-му элементу массива присваиваем новое значение odds; // ошибка доступа

5.3. Строки

Для записи строки программисты используют идею, что строка - последовательный ряд (массив) символов. Для идентификации конца строки используют специальный символ конца строки: ‘\0’. Такие специальные символы, состоящие из обратного слэша и идентифицирующего символа, называют управляющими или escape-символами. Ещё существуют, например, ‘\n’ - начало новой строки, ‘\t’ - табуляция. Для записи в строке обратного слэша применяют экранирование - перед самим знаком ставят ещё один слэш: ‘\’. Экранирование также применяют для записи кавычек.

Создадим переменную строки:

Char textExample = {‘T’, ‘e’, ‘s’, ‘t’, ‘\0’}; // записана строка «Test»

Существует упрощённая запись инициализации строки:

Char textExample = “Test”; // Последний символ не пишется, но размер всё ещё 5

Не вдаваясь в подробности, приведём ещё один полезный тип данных - string. Строки
такого типа можно, например, складывать:

String hello = "Привет, "; string name = "Макс!"; string hello_name = hello + name; // Получится строка «Привет, Макс!»

6. Ссылка

Int a = 2; // переменная «a» указывает на значение 2 int &b = a; // переменная «b» указывает туда же, куда и «a» b = 4; // меняя значение b, программист меняет значение a. Теперь a = 4 int &c = 4; // ошибка, так делать нельзя, т.к. ссылка нельзя присвоить значение

7. Указатель

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

Адреса 0x0 означает, что указатель пуст, т.е. не указывает ни на какие данные. Этот адрес имеет свой литерал - NULL:

Int *nullPtr = NULL; // пустой указатель

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

Операция получения данных, начинающихся по адресу, хранящемуся в указателе, называется разыменовывания (*). Программа считывает необходимое количество ячеек памяти и возвращает значение, хранимое в памяти.

Int valueInMemory = 2; // задаём переменну целого типа int *somePtr = &valueIntMemory; // копируем адрес переменной, здесь & - возвращает адрес переменной somePtr; // адрес ячейки памяти, например, 0x2F *somePtr; // значение хранится в 4-х ячейках: 0x2F, 0x30, 0x31 и 0x32

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

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

8. Перечисления

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

Enum color {RED, BLUE, GREEN};

По умолчанию, RED = 0, BLUE = 1, GREEN = 2. Поэтому значения можно сравнивать между собой, т.е. RED < BLUE < GREEN. Программист при объявлении перечисления может самостоятельно задать значения каждой из констант:

Enum access {READ = 1, WRITE = 2, EXEC = 4};

Часто удобно использовать перечисления, значения которых являются степенью двойки, т.к. в двоичном представлении число, являющееся степенью 2-и, будет состоять из 1-й единицы и нулей. Например:

8 10 = 00001000 2

Результат сложения этих чисел между собой всегда однозначно указывает на то, какие числа складывались:

37 10 = 00100101 2 = 00000001 2 + 00000100 2 + 00100000 2 = 1 10 + 4 10 + 32 10

Void

Синтаксически тип void относится к фундаментальным типам, но использовать его можно лишь как часть более сложных типов, т.к. объектов типа void не существует. Как правило, этот тип используется для информирования о том, что у функции нет возвращаемого значения либо в качестве базового типа указателя на объекты неопределённых типов:

Void object; // ошибка, не существует объектов типа void void &reference; // ошибка, не существует ссылов на void void *ptr; // ok, храним указатель на неизвестный тип

Часто мы будем использовать void именно для обозначения того, что функция не возвращает никакого значения. С указателем типа void работают, когда программист берёт полностью на себя заботу о целостности памяти и правильном приведении типа.

Приведение типов

Часто бывает необходимо привести значение переменной одного типа к другому. В случае, когда множество значений исходного типа является подмножеством большего типа (например, int является подмножеством long, а long - double), компилятор способен неявно (implicitly ) изменить тип значения.

Int integer = 2; float floating = integer; // floating = 2.0

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

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

Int value = (int) 2.5;

Унарные и бинарные операции

Те операции, которые мы выполняли ранее, называют бинарными: слева и справа от символа операции находятся значения или переменные, например, 2 + 3. В языках программирования помимо бинарных операций также используют унарные операции, которые применяются к переменным. Они могу находится как слева, так и справа от переменной, несколько таких операций встречались ранее - операция разыменовывания (*) и взятие адреса переменной (&) являются унарными. Операторы «++» и «—» увеличивают и уменьшают значение целочисленной переменной на 1 соответственно, причём могу писаться либо слева, либо справа от переменной.

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

A += 2; // то же самое, что и a = a + 2; b /= 5; // то же самое, что и b = b / 5; c &= 3; // то же самое, что и c = c & 3;