Бьерн Страуструп (Стpаустpуп - Книга о C++), страница 12

типа этих параметров. Тип void* имеют также бестиповые объекты,

возвращаемые функциями.

Для использования таких объектов нужно выполнить явную операцию

преобразования типа. Такие функции обычно находятся на самых нижних

уровнях системы, которые управляют аппаратными

ресурсами. Приведем пример:

void* malloc(unsigned size);

void free(void*);

void f() // распределение памяти в стиле Си

{

int* pi = (int*)malloc(10*sizeof(int));

char* pc = (char*)malloc(10);

//...

free(pi);

free(pc);

}

Обозначение: (тип) выражение - используется для задания операции

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

pi тип void*, возвращаемый в первом вызове malloc(), преобразуется

в тип int. Пример записан в архаичном стиле; лучший стиль

управления размещением в свободной памяти показан в $$3.2.6.

2.3.5 Указатели

Для большинства типов T указатель на T имеет тип T*. Это значит, что

переменная типа T* может хранить адрес объекта типа T. Указатели на

массивы и функции, к сожалению, требуют более сложной записи:

int* pi;

char** cpp; // указатель на указатель на char

int (*vp)[10]; // указатель на массив из 10 целых

int (*fp)(char, char*); // указатель на функцию с параметрами

// char и char*, возвращающую int

Главная операция над указателями - это косвенное обращение

(разыменование), т.е. обращение к объекту, на который настроен

указатель. Эту операцию обычно называют просто косвенностью.

Операция косвенности * является префиксной унарной операцией.

Например:

char c1 = 'a';

char* p = &c1; // p содержит адрес c1

char c2 = *p; // c2 = 'a'

Переменная, на которую указывает p,- это c1, а значение, которое

хранится в c1, равно 'a'. Поэтому присваиваемое c2 значение *p

есть 'a'.

Над указателями можно выполнять и некоторые арифметические операции.

Ниже в качестве примера представлена функция, подсчитывающая число

символов в строке, заканчивающейся нулевым символом (который

не учитывается):

int strlen(char* p)

{

int i = 0;

while (*p++) i++;

return i;

}

Можно определить длину строки по-другому: сначала найти ее конец, а затем

вычесть адрес начала строки из адреса ее конца.

int strlen(char* p)

{

char* q = p;

while (*q++) ;

return q-p-1;

}

Широко используются указатели на функции; они особо обсуждаются

в $$4.6.9

2.3.6 Массивы

Для типа T T[size] является типом "массива из size элементов типа T".

Элементы индексируются от 0 до size-1. Например:

float v[3]; // массив из трех чисел с плавающей точкой:

// v[0], v[1], v[2]

int a[2][5]; // два массива, из пяти целых каждый

char* vpc; // массив из 32 символьных указателей

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

значения прописных букв:

extern "C" int strlen(const char*); // из <string.h>

char alpha[] = "abcdefghijklmnopqrstuvwxyz";

main()

{

int sz = strlen(alpha);

for (int i=0; i<sz; i++) {

char ch = alpha[i];

cout << '\''<< ch << '\''

<< " = " <<int(ch)

<< " = 0" << oct(ch)

<< " = 0x" << hex(ch) << '\n';

}

}

Здесь функции oct() и hex() выдают свой параметр целого типа

в восьмеричном и шестнадцатеричном виде соответственно. Обе функции

описаны в <iostream.h>. Для подсчета числа символов в alpha

используется функция strlen() из <string.h>, но вместо нее можно

было использовать размер массива alpha ($$2.4.4). Для множества

символов ASCII результат будет таким:

'a' = 97 = 0141 = 0x61

'b' = 98 = 0142 = 0x62

'c' = 99 = 0143 = 0x63

...

Отметим, что не нужно указывать размер массива alpha: транслятор

установит его, подсчитав число символов в строке, заданной в качестве

инициализатора. Задание массива символов в виде строки инициализатора

- это удобный, но к сожалению, единственный способ подобного применения

строк. Присваивание строки массиву недопустимо, поскольку

в языке присваивание массивам не определено, например:

char v[9];

v = "a string"; // ошибка

Классы позволяют реализовать представление строк с большим набором

операций (см. $$7.10).

Очевидно, что строки пригодны только для инициализации символьных

массивов; для других типов приходится использовать более сложную

запись. Впрочем, она может использоваться и для символьных массивов.

Например:

int v1[] = { 1, 2, 3, 4 };

int v2[] = { 'a', 'b', 'c', 'd' };

char v3[] = { 1, 2, 3, 4 };

char v4[] = { 'a', 'b', 'c', 'd' };

Здесь v3 и v4 - массивы из четырех (а не пяти) символов; v4 не оканчивается

нулевым символом, как того требуют соглашение о строках и большинство

библиотечных функций. Используя такой массив char мы сами

готовим почву для будущих ошибок.

Многомерные массивы представлены как массивы массивов. Однако нельзя

при задании граничных значений индексов использовать, как это делается

в некоторых языках, запятую. Запятая - это особая операция для

перечисления выражений (см. $$3.2.2). Можно попробовать задать такое

описание:

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

или такое

int v[5][2];

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

int good = v[4][1]; // правильно

Ниже описывается

массив из двух элементов, каждый из которых является, в свою очередь,

массивом из 5 элементов типа char:

char v[2][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

<< "]=" << 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 Указатели и массивы

Указатели и массивы в языке Си++ тесно связаны. Имя массива можно

использовать как указатель на его первый элемент, поэтому пример с

массивом alpha можно записать так:

int main()

{

char alpha[] = "abcdefghijklmnopqrstuvwxyz";

char* p = alpha;

char ch;

while (ch = *p++)

cout << ch << " = " << int (ch)

<< " = 0" << oct(ch) << '\n';

}

Можно также задать описание p следующим образом:

char* p = &alpha[0];

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

параметром-массивом, который всегда передается как указатель на его

первый элемент. Таким образом, в следующем примере в обоих вызовах

strlen передается одно и то же значение:

void f()

{

extern "C" int strlen(const char*); // из <string.h>

char v[] = "Annemarie";

char* p = v;

strlen(p);

strlen(v);

}

Но в том и загвоэдка, что обойти это нельзя: не существует способа так

описать функцию, чтобы при ее вызове массив v копировался ($$4.6.3).

Результат применения к указателям арифметических операций +,

-, ++ или -- зависит от типа указуемых объектов. Если такая операция

применяется к указателю p типа T*, то считается, что p указывает на

массив объектов типа T. Тогда p+1 обозначает следующий элемент

этого массива, а p-1 - предыдущий элемент. Отсюда следует, что

значение (адрес) 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(pi+1)-long(pi) << '\n';

}

с учетом того, что на машине автора (Maccintosh) символ занимает один байт,

а целое - четыре байта, получим:

char* 1

int* 4

Перед вычитанием указатели были явной операцией преобразованы

к типу long ($$3.2.5). Он использовался для преобразования вместо

"очевидного" типа int, поскольку в некоторых реализациях языка С++

указатель может не поместиться в тип int (т.е. sizeof(int)<sizeof(char*)).

Вычитание указателей определено только в том случае, когда

они оба указывают на один и тот же массив (хотя в языке нет

возможностей гарантировать этот факт). Результат вычитания одного

указателя из другого равен числу (целое) элементов массива, находящихся

между этими указателями. Можно складывать с указателем или вычитать из него

значение целого типа; в обоих случаях результатом будет указатель.

Если получится значение, не являющееся указателем на элемент того же

массива, на который был настроен исходный указатель (или указателем на

следующий за массивом элемент), то результат использования такого

значения неопределен. Приведем пример:

void f()

{

int v1[10];

int v2[10];

int i = &v1[5]-&v1[3]; // 2

i = &v1[5]-&v2[3]; // неопределенный результат

int* p = v2+2; // p == &v2[2]

p = v2-2; // *p неопределено

}

Как правило, сложных арифметических операций с указателями не требуется

и лучше всего их избегать.

Следует сказать, что в

большинстве реализаций языка С++ нет контроля над границами массивов.

Описание массива не является самодостаточным, поскольку необязательно

в нем будет храниться число элементов массива.

Понятие массива в С является, по сути, понятием языка низкого

уровня. Классы помогают развить его (см. $$1.4.3).

2.3.8 Структуры

Массив представляет собой совокупность элементов одного типа, а

структура является совокупностью элементов произвольных

(практически) типов. Например:

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 jd;

jd.name = "Jim Dandy";

jd.number = 61;

Инициализировать переменные типа struct можно так же, как массивы.

Например:

address jd = {

"Jim Dandy",

61, "South Street",

"New Providence", {'N','J'}, 7974

};

Но лучше для этих целей использовать конструктор ($$5.2.4). Отметим,

что jd.state нельзя инициализировать строкой "NJ". Ведь строки

оканчиваются нулевым символом '\0', значит в строке "NJ" три символа,

а это на один больше, чем помещается в jd.state.

К структурным объектам часто обращаются c помощью указателей,

используя операцию ->. Например:

void print_addr(address* p)

{

cout << p->name << '\n'

<< p->number << ' ' << p->street << '\n'

<< p->town << '\n'

<< p->state[0] << p->state[1]

<< ' ' << p->zip << '\n';

}

Объекты структурного типа могут быть присвоены, переданы как фактические

параметры функций и возвращены функциями в качестве результата. Например:

address current;

address set_current(address next)

{

address prev = current;

current = next;

return prev;

}

Другие допустимые операции, например, такие, как сравнение (== и !=),

неопределены. Однако пользователь может сам определить эти операции