Бьерн Страуструп. Язык программирования С++


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



бет14/124
Дата16.07.2016
өлшемі3.27 Mb.
#204081
түріКнига
1   ...   10   11   12   13   14   15   16   17   ...   124

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


В присваивании и выражении основные типы могут совершенно свободно

использоваться совместно. Значения преобразовываются всюду, где

это возможно, таким образом, чтобы информация не терялась. Точные

правила преобразований даны в $$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. В С++ нет динамических средств контроля

подобных ситуаций, а контроль на этапе трансляции вообще слишком

сложен, поэтому надо быть осторожными.



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


Исходя из основных (и определенных пользователем) типов, можно с

помощью следующих операций описания:
* указатель

& ссылка


[] массив

() функция


а также с помощью определения структур, задать другие, производные типы.

Например:


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

избегать.



2.3.4 Тип 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.

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





Достарыңызбен бөлісу:
1   ...   10   11   12   13   14   15   16   17   ...   124




©dereksiz.org 2024
әкімшілігінің қараңыз

    Басты бет