3.3. Указатели

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

∙указатель на int, содержащий значение адреса 1000, направлен на область памяти 1000-1003 (в 32-битной системе);

∙указатель на double, содержащий значение адреса 1000, направлен на область памяти 1000-1007 (в 32-битной системе).

int *ip1, *ip2;

complex<double> *cp; string *pstring; vector<int> *pvec;

Вот несколько примеров: double *dp;

Указатель обозначается звездочкой перед именем. В определении переменных списком звездочка должна стоять перед каждым указателем (см. выше: ip1 и ip2). В примере ниже lp – указатель на объект типа long, а lp2 – объект типа long:

long *lp, lp2;

В следующем случае fp интерпретируется как объект типа float, а fp2 – указатель на него:

float fp, *fp2;

Оператор разыменования (*) может отделяться пробелами от имени и даже непосредственно примыкать к ключевому слову типа. Поэтому приведенные

string

*

p s

;

определения синтаксически правильны и совершенно эквивалентны: string* ps;

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

//внимание: ps2 не указатель на строку!

string* ps, ps2;

Можно предположить, что и ps, и ps2 являются указателями, хотя указатель – только первый из них.

Если значение указателя равно 0, значит, он не содержит никакого адреса объекта. Пусть задана переменная типа int:

int ival = 1024;

//pi инициализирован нулевым адресом int *pi = 0;

//pi2 инициализирован адресом ival int *pi2 = &ival;

//правильно: pi и pi2 содержат адрес ival

pi = pi2;

// pi2 содержит нулевой адрес

Ниже приводятся примеры определения и использования указателей на int pi и pi2: pi2 = 0;

// ошибка: pi не может принимать значение int

Указателю не может быть присвоена величина, не являющаяся адресом: pi = ival

Точно так же нельзя присвоить указателю одного типа значение, являющееся адресом

double

d v a l

;

объекта другого типа. Если определены следующие переменные: double *ps = &dval;

// ошибки

компиляц

ии

то оба выражения присваивания, приведенные ниже, вызовут ошибку компиляции:

// недопустимое присваивание типов данных: int* <== double* pi = pd

pi = &dval;

Дело не в том, что переменная pi не может содержать адреса объекта dval – адреса объектов разных типов имеют одну и ту же длину. Такие операции смешения адресов запрещены сознательно, потому что интерпретация объектов компилятором зависит от типа указателя на них.

Конечно, бывают случаи, когда нас интересует само значение адреса, а не объект, на который он указывает (допустим, мы хотим сравнить этот адрес с каким-то другим). Для

разрешения таких ситуаций введен специальный указатель void, который может

// правильно: void* может содержать

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

// адреса любого типа void *pv = pi;

pv = pd;

Тип объекта, на который указывает void*, неизвестен, и мы не можем манипулировать этим объектом. Все, что мы можем сделать с таким указателем, – присвоить его значение другому указателю или сравнить с какой-либо адресной величиной. (Более подробно мы расскажем об указателе типа void в разделе 4.14.)

Для того чтобы обратиться к объекту, имея его адрес, нужно применить операцию

разыменования, или косвенную адресацию, обозначаемую звездочкой (*). Имея

int ival = 1024;, ival2 = 2048;

следующие определения переменных: int *pi = &ival;

мы можем читать и сохранять значение ival, применяя операцию разыменования к

//косвенное присваивание переменной ival значения ival2 *pi = ival2;

//косвенное использование переменной ival как rvalue и

lvalue

*pi = abs(*pi); // ival = abs(ival);

указателю pi:

*pi = *pi + 1; // ival = ival + 1;

Когда мы применяем операцию взятия адреса (&) к объекту типа int, то получаем результат типа int*

int *pi = &ival;

Если ту же операцию применить к объекту типа int* (указатель на int), мы получим указатель на указатель на int, т.е. int**. int** – это адрес объекта, который содержит адрес объекта типа int. Разыменовывая ppi, мы получаем объект типа int*, содержащий адрес ival. Чтобы получить сам объект ival, операцию разыменования к ppi необходимо применить дважды.