Мюррей Хилл - C++ Страница 12

char v[9]; v = «строка»; // ошибка

ошибочно, поскольку присваивание не определено для векторов.

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

int v1[] = (* 1, 2, 3, 4 *); int v2[] = (* 'a', 'b', 'c', 'd' *);

char v3[] = (* 1, 2, 3, 4 *); char v4[] = (* 'a', 'b', 'c', 'd' *);

Заметьте, что v4 – вектор из четырех (а не пяти) символов; он не оканчивается нулем, как того требуют соглашение и библиотечные подпрограммы. Обычно применение такой записи ограничивается статическими объектами.

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

int bad[5,2]; // ошибка

и так:

int v[5][2];

int bad = v[4,1]; // ошибка int good = v[4][1]; // ошибка

Описание

char v[2][5];

описывает вектор из двух элементов, каждый из которых является вектором типа char[5]. В следующем примере первый из этих векторов инициализируется первыми пятью буквами, а второй – первыми пятью цифрами.

char v[2][5] = (* 'a', 'b', 'c', 'd', 'e', '0', '1', '2', '3', '4' *)

main() (* for (int i = 0; i«2; i++) (* for (int j = 0; j„5; j++) cout „„ „v[“ «« i «« «][“ «« j «« «]=“ «« chr(v[i][j]) «« " "; cout «« «\n“; *) *)

это дает в результате

v[0][0]=a v[0][1]=b v[0][2]=c v[0][3]=d v[0][4]=e v[1][0]=0 v[1][1]=1 v[1][2]=2 v[1][3]=3 v[1][4]=4

2.3.7 Указатели и Вектора

Указатели и вектора в С++ связаны очень тесно. Имя вектора можно использовать как указатель на его первый элемент, поэтому пример с алфавитом можно было написать так:

char alpha[] = «abcdefghijklmnopqrstuvwxyz»; char* p = alpha; char ch;

while (ch = *p++) cout «„ chr(ch) „« " = " «« ch «« « = 0“ «« oct(ch) «« «\n“;

Описание p можно было также записать как

char* p = amp;alpha[0];

Эта эквивалентность широко используется в вызовах функций, в которых векторный параметр всегда передается как указатель на первый элемент вектора. Так, в примере

extern int strlen(char*); char v[] = «Annemarie»; char* p = v; strlen(p); strlen(v);

функции strlen в обоих вызовах передается одно и то же значение. Вся штука в том, что этого невозможно избежать; то есть не существует способа описать функцию так, чтобы вектор v в вызове функции копировался (#4.6.3). Результат применения к указателям арифметических операций +, -, ++ или – зависит от типа объекта, на который они указывают. Когда к указателю p типа T* применяется арифметическая операция, предполагается, что p указывает на элемент вектора объектов типа T; p+1

означает следующий элемент этого вектора, а p предыдущий элемент. Отсюда следует, что значение p+1 будет на sizeof(T) больше значения p. Например, выполнение

main() (* char cv[10]; int iv[10];

char* pc = cv; int* pi = iv;

cout «„ "char* " „« long(pc+1)-long(pc) «« «\n“; cout «« "int* " «« long(ic+1)-long(ic) «« «\n“; *)

дает

char* 1 int* 4

поскольку на моей машине каждый символ занимает один байт, а каждое целое занимает четыре байта. Перед вычитанием значения указателей преобразовывались к типу long с помощью явного преобразования типа (#3.2.5). Они преобразовывались к long, а не к «очевидному» int, поскольку есть машины, на которых указатель не влезет в int (то есть, sizeof(int)«sizeof(long) ).

Вычитание указателей определено только тогда, когда оба указателя указывают на элементы одного и того же вектора (хотя в языке нет способа удостовериться, что это так). Когда из одного указателя вычитается другой, результатом является число элементов вектора между этими указателями (целое число). Можно добавлять целое к указателю или вычитать целое из указателя; в обоих случаях результатом будет значение типа указателя. Если это значение не указывает на элемент того же вектора, на который указывал исходный указатель, то результат использования этого значения неопределён. Например:

int v1[10]; int v2[10];

int i = amp;v1[5]– amp;v1[3]; // 2 i = amp;v1[5]– amp;v2[3]; // результат неопределен

int* p = v2+2; // p == amp;v2[2] p = v2-2; // p неопределено

2.3.8 Структуры

Вектор есть совокупность элементов одного типа, struct является совокупностью элементов (практически) произвольных типов. Например:

struct address (* // почтовый адрес char* name; // имя «Jim Dandy» long number; // номер дома 61 char* street; // улица «South Street» char* town; // город «New Providence» char* state[2]; // штат 'N' 'J' int zip; // индекс 7974 *)

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

является достаточным для работы с полным почтовым адресом, но в качестве примера достаточен). Обратите внимание на точку с запятой в конце; это одно из очень немногих мест в С++, где необходимо ставить точку с запятой после фигурной скобки, поэтому люди склонны забывать об этом.

Переменные типа address могут описываться точно также, как другие переменные, а доступ к отдельным членам получается с помощью операции . (точка). Например:

address jd; jd.name = «Jim Dandy»; jd.number = 61;

Запись, которая использовалась для инициализации векторов, можно применять и к переменным структурных типов. Например:

address jd = (* «Jim Dandy», 61, «South Street», «New Providence», (*'N','J'*), 7974 *);

Однако обычно лучше использовать конструктор (#5.2.4). Заметьте, что нельзя было бы инициализировать jd.state строкой «NJ». Строки оканчиваются символом '\0', поэтому в «NJ» три символа, то есть на один больше, чем влезет в jd.state.

К структурным объектам часто обращаются посредством указателей используя операцию -». Например:

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“; *)

Объекты типа структура можно присваивать, передавать как параметры функции и возвращать из функции в качестве результата. Например:

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 вызвало бы к синтаксическую ошибку.

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 amp; означает ссылка на x. Например:

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

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

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

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

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

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