2.3.9 Эквивалентность типов

Два структурных типа являются различными даже когда они имеют одни и те же члены. Например:

struct s1 (* int a; *);

struct s2 (* int a; *);

есть два разных типа, поэтому

s1 x;

s2 y = x; // ошибка: несоответствие типов

Структурные типы отличны также от основных типов, поэто­му

s1 x;

int i = x; // ошибка: несоответствие типов

Однако, существует механизм для описания нового имени для типа без введения нового типа. Описание с префиксом typedef описывает не новую переменную данного типа, а новое имя этого типа. Например:

typedef char* Pchar;

Pchar p1, p2; char* p3 = p1;

Это может служить удобной сокращенной записью.

2.3.10 Ссылки

Ссылка является другим именем объекта. Главное примене­ние ссылок состоит в спецификации операций для типов, опреде­ляемых пользователем; они обсуждаются в Главе 6. Они могут также быть полезны в качестве параметров функции. Запись x& означает ссылка на x. Например:

int i = 1;

int& r = i; // r и i теперь ссылаются на один int

int x = r // x = 1

r = 2; // i = 2;

Ссылка должна быть инициализирована (должно быть что-то, для чего она является именем). Заметьте, что инициализация ссылки есть нечто совершенно отличное от присваивания ей.

Вопреки ожиданиям, ни одна операция на ссылку не дейс­твует. Например:

int ii = 0;

int& rr = ii;

rr++; // ii увеличивается на 1

допустимо, но rr++ не увеличивает ссылку; вместо этого + + применяется к int, которым оказывается ii. Следовательно, после инициализации значение ссылки не может быть изменено; она всегда ссылается на объект, который ей было дано обозна­чать (денотировать) при инициализации. Чтобы получить указа­тель на объект, денотируемый ссылкой rr, можно написать &rr.

Очевидным способом реализации ссылки является констант­ный указатель, который разыменовывается при каждом использо­вании. Это делает инициализацию ссылки тривиальной, когда инициализатор является lvalue (объектом, адрес которого вы можете взять, см. #с.5). Однако инициализатор для &T не обя­зательно должен быть lvalue, и даже не должен быть типа T. В таких случаях:

[1] Во-первых, если необходимо, применяется преобразова­ние типа (#с.6.6-8, #с.8.5.6),

[2] Затем полученное значение помещается во временную переменную и

[3] Наконец, ее адрес используется в качестве значения инициализатора.

Рассмотрим описание

double& dr = 1;

Это интерпретируется так:

double* drp; // ссылка, представленная как указатель

double temp;

temp = double(1);

drp = &temp;

int x = 1;

void incr(int& aa) (* aa++; *)

incr(x) // x = 2

По определению семантика передачи параметра та же, что семантика инициализации, поэтому параметр aa функции incr становится другим именем для x. Однако, чтобы сделать прог­рамму читаемой, в большинстве случаев лучше всего избегать функций, которые изменяют значение своих параметров. Часто предпочтительно явно возвращать значение из функции или тре­бовать в качестве параметра указатель:

int x = 1;

int next(int p) (* return p+1; *)

x = next(x); // x = 2

void inc(int* p) (* (*p)++; *)

inc(&x); // x = 3

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

struct pair (*

char* name;

int val;

*);

Основная идея состоит в том, что строка имеет ассоцииро­ванное с ней целое значение. Легко определить функцию поиска find(), которая поддерживает структуру данных, состоящую из одного pair для каждой отличной отличной от других строки, которая была ей представлена. Для краткости представления ис­пользуется очень простая (и неэффективная) реализация:

const large = 1024;

static pair vec[large+1*);

pair* find(char* p)

/*

поддерживает множество пар "pair":

ищет p, если находит, возвращает его "pair",

иначе возвращает неиспользованную "pair"

*/

(*

for (int i=0; vec[i].name; i++)

if (strcmp(p,vec[i].name)==0) return &vec[i];

if (i == large) return &vec[large-1];

return &vec[i];

*)

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

int& value(char* p)

(*

pair* res = find(p);

if (res->name == 0) (* // до сих пор не встречалось:

res->name = new char[strlen(p)+1]; // инициализи-

// ровать strcpy(res->name,p);

res->val = 0; // начальное значение 0

*)

return res->val;

*)

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

const MAX = 256; // больше самого большого слова

main()

// подсчитывает число вхождений каждого слова во вводе

(*

char buf[MAX];

while (cin>>buf) value(buf)++;

for (int i=0; vec[i].name; i++)

cout << vec[i].name << ": " << vec [i].val << "\n"; *)

На каждом проходе цикл считывает одно слово из стандарт­ной строки ввода cin в buf (см. Главу 8), а затем обновляет связанный с ней счетчик с помощью find(). И, наконец, печата­ется полученная таблица различных слов во введенном тексте, каждое с числом его встречаемости. Например, если вводится

aa bb bb aa aa bb aa aa

то программа выдаст:

aa: 5

bb: 3

Легко усовершенствовать это в плане собственного типа ассоциированного массива с помощью класса с перегруженной операцией (#6.7) выбора [].