Неявное преобразование типа




В присваивании и выражении основные типы могут совершенно свободноиспользоваться совместно. Значения преобразовываются всюду, гдеэто возможно, таким образом, чтобы информация не терялась. Точныеправила преобразований даны в $$R.4 и $$R.5.4. Все-таки есть ситуации, когда информация может быть потеряна илидаже искажена. Потенциальным источником таких ситуаций становятсяприсваивания, в которых значение одного типа присваивается значениюдругого типа, причем в представлении последнего используетсяменьше разрядов. Допустим, что следующие присваивания выполняютсяна машине, в которой целые представляются в дополнительном коде, и символзанимает 8 разрядов: int i1 = 256+255; char ch = i1 // ch == 255 int i2 = ch; // i2 ==? В присваивании ch=i1 теряется один разряд (и самый важный!), а когдамы присваиваем значение переменной i2, у переменной ch значение "всеединицы", т.е. 8 единичных разрядов. Но какое значение примет i2? Намашине DEC VAX, в которой char представляет знаковые значения, это будет-1, а на машине Motorola 68K, в которой char - беззнаковый,это будет 255. В С++ нет динамических средств контроляподобных ситуаций, а контроль на этапе трансляции вообще слишкомсложен, поэтому надо быть осторожными.

Производные типы

Исходя из основных (и определенных пользователем) типов, можно спомощью следующих операций описания: * указатель & ссылка [] массив () функция а также с помощью определения структур, задать другие, производные типы.Например: int* a; float v[10]; char* p[20]; // массив из 20 символьных указателей void f(int); struct str { short length; char* p; }; Правила построения типов с помощью этих операций подробно объясненыв $$R.8. Ключевая идея состоит в том, что описание объекта производноготипа должно отражать его использование, например: int v[10]; // описание вектора i = v[3]; // использование элемента вектора int* p; // описание указателя i = *p; // использование указуемого объекта Обозначения, используемые для производных типов, достаточно трудныдля понимания лишь потому, что операции * и & являются префиксными, а[] и () - постфиксными. Поэтому в задании типов, если приоритетыопераций не отвечают цели, надо ставить скобки. Например, приоритетоперации [] выше, чем у *, и мы имеем: int* v[10]; // массив указателей int (*p)[10]; // указатель массива Большинство людей просто запоминает, как выглядят наиболее частоупотребляемые типы.Можно описать сразу несколько имен в одном описании. Тогда оно содержитвместо одного имени список отделяемых друг от друга запятымиимен. Например, можно так описать две переменные целого типа: int x, y; // int x; int y; Когда мы описываем производные типы, не надо забывать, что операцииописаний применяются только к данному имени (а вовсе не ко всемостальным именам того же описания). Например: int* p, y; // int* p; int y; НО НЕ int* y; int x, *p; // int x; int* p; int v[10], *p; // int v[10]; int* p; Но такие описания запутывают программу, и, возможно, их следуетизбегать.

Тип void

Тип void синтаксически эквивалентен основным типам, но использоватьего можно только в производном типе. Объектов типа void не существует.С его помощью задаются указатели на объекты неизвестного типа илифункции, невозвращающие значение. void f(); // f не возвращает значения void* pv; // указатель на объект неизвестного типа Указатель произвольного типа можно присваивать переменной типа void*.На первый взгляд этому трудно найти применение, поскольку для void*недопустимо косвенное обращение (разыменование). Однако, именнона этом ограничении основывается использование типа void*. Онприписывается параметрам функций, которые не должны знать истинноготипа этих параметров. Тип 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.

Указатели

Для большинства типов 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

Массивы

Для типа 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

Указатели и массивы

Указатели и массивы в языке Си++ тесно связаны. Имя массива можно использовать как указатель на его первый элемент, поэтому пример с массивом 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).

Структуры

Массив представляет собой совокупность элементов одного типа, а структура является совокупностью элементов произвольных (практически) типов. Например: 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; } Другие допустимые операции, например, такие, как сравнение (== и!=),неопределены. Однако пользователь может сам определить эти операции(см. главу 7). Размер объекта структурного типа не обязательно равен суммеразмеров всех его членов. Это происходит по той причине, чтона многих машинах требуется размещать объекты определенных типов,только выравнивая их по некоторой зависящей от системы адресациигранице (или просто потому, что работа при таком выравнивании будетболее эффективной). Типичный пример - это выравнивание целого пословной границе. В результате выравнивания могут появиться "дырки" вструктуре. Так, на уже упоминавшейся машине автора 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; list* member_of; }; struct list { link* head; }; Если бы не было первого описания list, описание члена link привело бы ксинтаксической ошибке.Можно также использовать имя структурного типа еще до того, как тип будетопределен, если только это использование не предполагает знания размераструктуры. Например: class S; // 'S' - имя некоторого типа extern S a; S f(); void g(S); Но приведенные описания можно использовать лишь после того, как тип Sбудет определен: void h() { S a; // ошибка: S - неописано f(); // ошибка: S - неописано g(a); // ошибка: S - неописано }

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

Два структурных типа считаются различными даже тогда, когда они имеютодни и те же члены. Например, ниже определены различные типы: 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; Это просто удобное средство сокращения записи.

Ссылки

Ссылку можно рассматривать как еще одно имя объекта. В основном ссылки используются для задания параметров и возвращаемых функциями значений, а также для перегрузки операций (см.$$7). Запись X& обозначает ссылку на X. Например: int i = 1; int& r = i; // r и i ссылаются на одно и то же целое int x = r; // x = 1 r = 2; // i = 2; Ссылка должна быть инициализирована, т.е.должно быть нечто, что она может обозначать. Следует помнить, чтоинициализация ссылки совершенно отличается от операции присваивания.Хотя можно указывать операции над ссылкой, ни одна из них на саму ссылкуне действует, например, int ii = 0; int& rr = ii; rr++; // ii увеличивается на 1 Здесь операция ++ допустима, но rr++ не увеличивает самуссылку rr; вместо этого ++ применяется к целому, т.е. к переменной ii.Следовательно, после инициализации значение ссылки не может бытьизменено: она всегда указывает на тот объект, к которому была привязанапри ее инициализации. Чтобы получить указатель на объект,обозначаемый ссылкой rr, можно написать &rr.Очевидной реализацией ссылки может служить постоянный указатель,который используется только для косвенного обращения. Тогда инициализацияссылки будет тривиальной, если в качестве инициализатора указан адрес(т.е. объект, адрес которого можно получить; см. $$R.3.7).Инициализатор для типа T должен быть адресом. Однако, инициализатордля &T может быть и не адресом, и даже не типом T. В таких случаяхделается следующее:[1] во-первых, если необходимо, применяется преобразование типа (см.$$R.8.4.3);[2] затем получившееся значение помещается во временную переменную;[3] наконец, адрес этой переменной используется в качестве инициализатора ссылки.Пусть имеются описания: double& dr = 1; // ошибка: нужен адрес const double& cdr = 1; // нормально Это интерпретируется так: double* cdrp; // ссылка, представленная как указатель double temp; temp = double(1); cdrp = &temp; Ссылки на переменные и ссылки на константы различаются по следующейпричине: в первом случае создание временной переменной чреватоошибками, поскольку присваивание этой переменной означает присваиваниевременной переменной, которая могла к этому моменту исчезнуть.Естественно, что во втором случае подобных проблем не существует.и ссылки на константы часто используются как параметры функций(см.$$R.6.3).Ссылка может использоваться для функции, которая изменяет значение своегопараметра. Например: void incr(int& aa) { aa++; } void f() { int x = 1; incr(x); // x = 2 } По определению передача параметров имеет ту же семантику, что иинициализация, поэтому при вызове функции incr ее параметр aaстановится другим именем для x. Лучше, однако, избегать изменяющихсвои параметры функций, чтобы не запутывать программу. В большинствеслучаев предпочтительнее, чтобы функция возвращала результат явнымобразом, или чтобы использовался параметр типа указателя: int next(int p) { return p+1; } void inc(int* p) { (*p)++; } void g() { int x = 1; x = next(x); // x = 2 inc(&x); // x = 3 } Кроме перечисленного, с помощью ссылок можно определить функции, используемые как в правой, так и в левой частях присваивания. Наиболее интересное применение это обычно находит при определении нетривиальных пользовательских типов. В качестве примера определим простой ассоциативный массив. Начнем с определения структуры pair: struct pair { char* name; // строка int val; // целое }; Идея заключается в том, что со строкой связывается некоторое целое значение.Нетрудно написать функцию поиска find(), которая работает со структуройданных, представляющей ассоциативный массив. В нем для каждой отличной отдругих строки содержится структура pair (пара: строка и значение). Вданном примере - это просто массив. Чтобы сократить пример, используетсяпредельно простой, хотя и неэффективный алгоритм: const int large = 1024; static pair vec[large+1]; pair* find(const 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(const 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 int 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'; } В цикле while из стандартного входного потока cin читается по одному слову и записывается в буфер buf (см. глава 10), при этом каждый раз значение счетчика, связанного со считываемой строкой, увеличивается. Счетчик отыскивается в ассоциативном массиве vec с помощью функции find(). В цикле for печатается получившаяся таблица различных слов из cin вместе с их частотой. Имея входной поток aa bb bb aa aa bb aa aa программа выдает: aa: 5 bb: 3 С помощью шаблонного класса и перегруженной операции [] ($$8.8)достаточно просто довести массив из этого примера до настоящегоассоциативного массива.

ЛИТЕРАЛЫ

В С++ можно задавать значения всех основных типов:символьные константы, целые константы и константы с плавающей точкой.Кроме того, нуль (0) можно использовать как значение указателяпроизвольного типа, а символьные строки являются константами типаchar[]. Есть возможность определить символические константы.Символическая константа - это имя, значение которого в его областивидимости изменять нельзя. В С++ символические константы можно задатьтремя способами: (1) добавив служебное слово const в определении,можно связать с именем любое значение произвольного типа;(2) множество целых констант можно определить как перечисление;(3) константой является имя массива или функции.

Целые константы

Целые константы могут появляться в четырех обличьях: десятичные,восьмеричные, шестнадцатеричные и символьные константы. Десятичныеконстанты используются чаще всего и выглядят естественно: 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 представляется как 16-разрядноечисло в дополнительном коде, 0xffff есть отрицательное десятичноечисло -1. Если бы для представления целого использовалось большее числоразрядов, то это было бы числом 65535. Окончание U может использоваться для явного задания констант типаunsigned. Аналогично, окончание L явно задает константу типа long.Например: void f(int); void f(unsigned int); void f(long int); void g() { f(3); // вызов f(int) f(3U); // вызов f(unsigned int) f(3L); // вызов f(long int) }


Поделиться:




Поиск по сайту

©2015-2024 poisk-ru.ru
Все права принадлежать их авторам. Данный сайт не претендует на авторства, а предоставляет бесплатное использование.
Дата создания страницы: 2016-02-16 Нарушение авторских прав и Нарушение персональных данных


Поиск по сайту: