Обозначения
Комментарии выделяются так:
// комментарий
Куски кода на C++ выделяются так:
int a = 5; // кусок кода на C++
Текущие значения переменных выделяются так:
// a => 5
Краткое описание объявления и примеры использования
// переменные
char c = ‘a’;
int a = 5;
float b;
b = 3.14;
a = -1;
// переменные-указатели
int *p1;
int *p2 = &a;
int *p3 = p2;
int *p4;
p4 = &a;
p4 = p3;
// использование
int a = 5;
// перем. a получает значение 5
int *p = &a;
// переменная-указатель p получает адрес переменной a
// или: переменная-указатель p теперь указывает на переменную a
// *p => 5
int b = *p;
// перем. b получает значение перем., на которую указывает p
// b => 5
*p = 6;
// перем., на которую указывает p, получает значение 6
// *p => 6
// a => 6
// b => 5
Если вы не понимаете, как это все работает, то вам придется читать полное описание J.
Полное описание
Переменная
Что такое переменная? Переменная – это определенное место в памяти, имеющее имя, по которому мы его используем. Переменная имеет значение (текущее значение), грубо говоря, это то, что записано сейчас по определенному месту в памяти. Переменная также имеет тип, описывающий, какого рода значения в ней хранятся.
Переменные устроены таким образом, что мы можем работать с ними по их имени, не задумываясь, где на самом деле в памяти и как они хранятся – это их главная идея.
Прежде чем использовать переменную, ее надо объявить и определить ее тип. Одновременно с этим можно задать начальное значение, а можно установить значение переменной после, в любой момент.
float f; // объявляем перем. f типа float
char s = ‘w’; // объяв. перем. s типа char и присв. ей знач. ‘w’
f = -3.2; // перем. f присв. значение -3.2
int a = 5; // объявляем перем. a типа int и присв. ей значение 5
int b = 6; // объявляем перем. b типа int и присв. ей значение 6
int t; // объявляем перем. t типа int
t = a; // переменной t присваиваем значение переменной a
a = b; // переменной a присваиваем значение переменной b
b = t; // переменной b присваиваем значение переменной t
Во многих языках это было бы практически все, что можно делать с переменными, как с ними работать. Однако в С++, как в языке низкого уровня, с переменными можно работать и по-другому, а именно – косвенно.
Для того, чтобы в этом разобраться, нужно для начала разобраться в том, что представляет из себя память, в которой переменные хранятся. Ведь переменные имеют различные типы, а память одна – как в одной и той же памяти хранятся и целые числа, и дробные числа, и символы, и так далее.
Память
Память – это нумерованная последовательность числовых двоичных байтов. Именно нумерованная (то есть каждый байт имеет номер), именно последовательность (то есть каждый следующий байт имеет номер, отличающийся на единицу), именно двоичных (то есть байт содержит 8 двоичных битов, содержащих, в свою очередь, 0 или 1), именно байтов (то есть можно обратиться только[1] к байту целиком, но не к отдельному биту), и именно числовых (то есть каждый байт представляет из себя число).
Каждый байт этой последовательности имеет свой номер и текущее значение, которое, как несложно догадаться, в двоичном виде представляет из себя число от 00000000 до 11111111, в шестнадцатеричном виде – число от 00 до FF, и в десятичном виде – число от 0 до 255:
| значение | |||||||||
| номер |
Как уже говорилось выше, каждая переменная занимает некоторое место в памяти. Разные типы требуют различного количества байтов. Еще раз: переменная – это определенное место в памяти, имеющее имя, по которому мы его используем. Теперь мы можем сказать более точно. Определенное место – это некоторая определенная непрерывная последовательность байтов в памяти:
| значение | |||||||||
| номер | |||||||||
| переменная | не занято | s | a | b | не занято | ||||
| тип | char | int | int | ||||||
| значение | ‘w’ |
Что мы здесь видим? Во-первых, все переменные занимают разное количество (подряд идущих!) байтов. Во-вторых, некоторые байты могут быть не заняты, но, смотря только на значения этих байтов, не скажешь, заняты они или нет, и значениями каких типов заняты. Незанятые байты могут иметь произвольные значения, оставшиеся от каких-то переменных, которые там раньше размещались, но теперь не размещаются. Иногда мы такие байты будем помечать символами ‘?’, но надо обязательно держать в уме, что там не вопросы находятся, а какие-то реальные значения.
И, в-третьих, и в самых главных, все переменные хранятся в той же самой памяти, которая состоит из числовых байтов. Внимание, вопрос. Как различные типы данных могут храниться в одной и той же памяти? Как в числовой памяти можно хранить символ ‘w’? Как в двух ячейках, каждая из которых может содержать число от 0 до 255, можно хранить число 258?
Ответы на эти вопросы у вас есть в лекциях. Для каждого типа данных известно, сколько байтов в памяти занимает переменная его типа (для char – один байт, для int – два байта[2], и так далее), и, самое главное, – как любое значение этого типа представить в виде последовательности числовых байтов. Для каждого значения char, например, выделяется один байт, и в этом числовом байте хранится номер этого символа в специальной таблице ascii.
Теперь, когда мы разобрались, что такое память, и как там хранятся переменные, нужно понять, что такое адрес переменной.
Адрес переменной
Адрес переменной – это, грубо говоря, номер первого байта, занимаемого этой переменной в памяти. В вышеприведенном примере, адрес переменной s есть 1, адрес переменной a есть 2, адрес переменной b есть 4. Зная адрес некоторой переменной, и зная ее тип, можно точно узнать, с какого по какой байты в памяти эта переменная занимает. А именно, байты с номерами с адрес(переменной) по адрес(переменной) + размер(переменной) - 1.
Для каждой переменной можно узнать ее адрес, с помощью операции &. Адрес – это, грубо говоря, номер, то есть число. Но не все операции над адресом допустимы и, что важнее, осмысленны.
Приведу такую аналогию. Адрес – это, например, номер почтового ящика. Если рассмотреть ящик номер 5, то его адрес – это, соответственно 5. К этому адресу я могу прибавить какое-то число, например, 2, и получить новый адрес, а именно 7. Если рассмотреть ящик номер 5 и ящик номер 8, то я могу из адреса второго вычесть адрес первого и получить уже не адрес, но число, равное количеству ящиков между ящиком номер 5 и ящиком номер 8. Но складывать два адреса нельзя, это бессмысленная операция.
Итак, над адресами переменных возможны следующие операции:
адрес2 – адрес1 => число1
– количество байтов между байтами по адресам адрес1 и адрес2;
адрес1 + число1 => адрес2
– адрес байта, отстоящего от байта по адресу адрес1 на число1 байтов
int a = 5;
int b = 6;
if (&b - &a > 10) /* переменные далеко друг от друга */
if (&a + 1 == &b) /* перем. b идет в памяти сразу за a */
Важный вопрос – а если мы захотим получить адрес некоторой переменной и сохранить его временно где-то в памяти, какого размера область памяти нам надо выделить? Или подобный вопрос: в переменную какого типа можно записать адрес? Если адрес – это номер, то ответ зависит от того, как много может быть таких адресов? В общем-то, адресов может быть столько, сколько ячеек в памяти, а это может быть и 10^9, и даже больше.
Теперь, когда мы разобрались, что такое память, и как там хранятся переменные, можно переходить непосредственно к указателям.
