void print_addr(address* p)
{
cout << p->name << "\n"
<< p->number << " " << p->street << "\n"
<< p->town << "\n"
<< chr(p->state[0]) << chr(p->state[1])
<< " " << p->zip << "\n";
}
Объекты типа структур можно присваивать, передавать как параметры
функции и возвращать из функции в качестве результата. Например:
- стр 62 -
address current;
address set_current(address next)
{
address prev = current;
current = next;
return prev;
}
Остальные осмысленные операции, такие как сравнение (== и !=) не
определены. Однако пользователь может определить эти операции; см.
Главу 6.
Размер объекта структурного типа нельзя вычислить просто как
сумму его членов. Причина этого состоит в том, что многие машины
требуют, чтобы объекты определенных типов выравнивались в памяти
только по некоторым зависящим от архитектуры границам (типичный
пример: целое должно быть выравнено по границе слова) или просто
гораздо более эффективно обрабатывают такие объекты, если они
выравнены в машине. Это приводит к "дырам" в структуре. Например,
(на моей машине) sizeof(address) равен 24, а не 22, как можно было
ожидать.
Заметьте, что имя типа становится доступным сразу после того, как
оно встретилось, а не только после того, как полностью просмотрено
все описание. Например:
struct link{
link* previous;
link* successor;
}
Новые объекы структурного типа не могут быть описываться, пока все
описание не просмотрено, поэтому
struct no_good {
no_good member;
};
является ошибочным (компилятор не может установить размер no_good).
Чтобы дать возможность двум (или более) структурным типам ссылаться
друг на друга, можно просто описать имя как имя структурного типа.
Например:
struct list; // должна быть определена позднее
struct link {
link* pre;
link* suc;
link* member_of;
};
struct list {
link* head;
}
Без первого описания list описание link вызвало бы к синтаксическую
ошибку.
- стр 63 -
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. Следовательно, после
инициализации значение ссылки не может быть изменено; она всегда
ссылается на объект, который ей было дано обозначать (денотировать)
- стр 64 -
при инициализации. Чтобы получить указатель на объект, денотируемый
ссылкой 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
Ссылки также можно применять для определения функций, которые
могут использоваться и в левой, и в правой части присваивания.
Опять, большая часть наиболее интересных случаев этого
обнаруживается в проектировании нетривиальных определяемых
пользователем типов. Для примера давайте определим простой
ассоциативный массив. Вначале мы определим структуру пары следующим
образом:
- стр 65 -
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() находит целый объект
(а не значение соответствующего целого); после чего она возвращает
ссылку на него. Ее можно использовать, например, так:
- стр 66 -
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) выбора [].
2.3.11 Регистры
Во многих машинных архитектурах можно обращаться к (небольшим)
объектам заметно быстрее, когда они помещены в регистр. В идеальном
случае компилятор будет сам определять оптимальную стратегию
использования всех регистров, доступных на машине, для которой
компилируется программа. Однако это нетривиальная задача, поэтому
иногда программисту стоит дать подсказку компилятору. Это делается
с помощью описания объекта как register. Например:
register int i;
register point cursor;
register char* p;
Описание register следует использовать только в тех случаях, когда
эффективность действительно важна. Описание каждой переменной как
register засорит текст программы и может даже увеличить время
выполнения (обычно воспринимаются все инструкции по помещению
объекта в регистр или удалению его оттуда).
Невозможно получить адрес имени, описанного как register, регистр
не может также быть глобальным.
- стр 67 -
2.4 Константы
C++ дает возможность записи значений основных типов: символьных
констант, целых констант и констант с плавающей точкой. Кроме того,
ноль (0) может использоваться как константа любого указательного
типа, и символьные строки являются константами типа char[]. Можно
также задавать символические константы. Символическая константа -
это имя, значение которого не может быть изменено в его области
видимости. В C++ имеется три вида символических констант: (1)
любому значению любого типа можно дать имя и использовать его как
константу, добавив к его описанию ключевое слово const; (2)
множество целых констант может быть определено как перечисление; и
(3) любое имя вектора или функции является константой.
2.4.1 Целые Константы
Целые константы предстают в четырех обличьях: десятичные,
восьмеричные, шестнадцатиричные и символьные константы. Десятичные
используются чаще всего и выглядят так, как можно было бы ожидать:
0 1234 976 12345678901234567890
Десятичная константа имеет тип int, при условии, что она влезает в
int, в противном случае ее тип long. Компилятор должен
предупреждать о константах, которые слишком длинны для
представления в машине.
Константа, которая начинается нулем за которым идет x (0x),
является шестнадцатиричным числом (с основанием 16), а константа,
которая начинается нулем за которым идет цифра, является
восьмеричным числом (с основанием 8). Вот примеры восьмеричных
констант:
0 02 077 0123
их десятичные эквиваленты - это 0, 2, 63, 83. В шестнадцатиричной
записи эти константы выглядят так:
0x0 0x2 0x3f 0x53
Буквы a, b, c, d, e и f, или их эквиваленты в верхнем регистре,
используются для представления чисел 10, 11. 12, 13, 14 и 15,
соответственно. Восьмеричная и шестнадцатиричная записи наиболее
полезны для записи набора битов; применение этих записей для
выражения обычных чисел может привести к неожиданностям. Например,
на машине, где int представляется как двоичное дополнительное
шестнадцатеричное целое, 0xffff является отрицательным десятичным
числом -1; если бы для представления целого использовалось большее
число битов, то оно было бы числом 65535.
