* законченный учебник и руководство по языку

Вид материала

Подобный материал:

1 2 3 4 5 6 7 8 9 ... 34

. Она нужна лишь в тех из них, которые

выдают результат.

Операция "++" является инкрементом, т. е. a++ означает: добавить 1

к переменной a.

Глобальная переменная или локальная переменная static, которая не была

явно инициализирована, инициализируется неявно нулевым значением (#2.4.5).

Используя операции new и delete, программист может создавать

объекты, временем жизни которых он управляет сам (см. $$3.2.6).

2.2 ИМЕНА

Имя (идентификатор) является последовательностью букв или цифр.

Первый символ должен быть буквой. Буквой считается и символ

подчеркивания _. Язык С++ не ограничивает число символов в имени.

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

транслятора управлять не может (например, загрузчик), а они,

к сожалению, могут устанавливать ограничения. Кроме того, некоторые

системные программы, необходимые для выполнения программы на С++, могут

расширять или сужать множество символов, допустимых в идентификаторе.

Расширения (например, использование $ в имени) могут нарушить

переносимость программы. Нельзя использовать в качестве имен

служебные слова С++ (см. $$R.2.4), например:

hello this_is_a_most_unusially_long_name

DEFINED foO bAr u_name HorseSense

var0 var1 CLASS _class ___

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

использоваться как идентификаторы:

012 a fool $sys class 3var

pay.due foo~bar .name if

Заглавные и строчные буквы считаются различными, поэтому Count и

count - разные имена. Но выбирать имена, почти не отличающиеся

друг от друга, неразумно. Все имена, начинающиеся с символа

подчеркивания, резервируются для использования в самой реализации

или в тех программах, которые выполняются совместно с рабочей,

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

свою программу.

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

длинную последовательность символов, образующих имя, поэтому var10

- это имя, а не идущие подряд имя var и число 10. По той же причине

elseif - одно имя (служебное), а не два служебных имени else и if.

2.3 ТИПЫ

С каждым именем (идентификатором) в программе связан тип. Он

задает те операции, которые могут применяться к имени (т.е. к объекту,

который обозначает имя), а также интерпретацию этих операций.

Приведем примеры:

int error_number;

float real(complex* p);

Поскольку переменная error_number описана как int (целое), ей можно

присваивать, а также можно использовать ее значения в арифметических

выражениях. Функцию real можно вызывать с параметром, содержащим

адрес complex. Можно получать адреса и переменной, и функции.

Некоторые имена, как в нашем примере int и complex, являются именами

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

другое имя. Кроме того, имя типа может использоваться

в качестве операнда в операциях sizeof (с ее помощью определяют

размер памяти, необходимый для объектов этого типа) и new (с ее

помощью можно разместить в свободной памяти объект этого типа).

Например:

int main()

{

int* p = new int;

cout << "sizeof(int) = " << sizeof(int) '\n';

}

Еще имя типа может использоваться в операции явного преобразования

одного типа к другому ($$3.2.5), например:

float f;

char* p;

//...

long ll = long(p); // преобразует p в long

int i = int(f); // преобразует f в int

2.3.1 Основные типы

Основные типы С++ представляют самые распространенные единицы памяти

машин и все основные способы работы с ними. Это:

char

short int

int

long int

Перечисленные типы используются для представления различного

размера целых. Числа с плавающей точкой представлены типами:

float

double

long double

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

логических значений, разрядных массивов и т.д.:

unsigned char

unsigned short int

unsigned int

unsigned long int

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

типов:

signed char

signed short int

signed int

signed long int

Поскольку по умолчанию значения типа int считаются знаковыми, то

соответствующие типы с signed являются синонимами типов без

этого служебного слова.

Но тип signed char представляет особый интерес: все 3 типа - unsigned char,

signed char и просто char считаются различными (см. также $$R.3.6.1).

Для краткости (и это не влечет никаких последствий) слово int можно

не указывать в многословных типах, т.е. long означает long int, unsigned -

unsigned int. Вообще, если в описании не указан тип, то предполагается,

что это int. Например, ниже даны два определения объекта типа int:

const a = 1; // небрежно, тип не указан

static x; // тот же случай

Все же обычно пропуск типа в описании в надежде, что по умолчанию

это будет тип int, считается дурным стилем. Он может вызвать тонкий и

нежелательный эффект (см. $$R.7.1).

Для хранения символов и работы с ними наиболее подходит тип char.

Обычно он представляет байт из 8 разрядов. Размеры всех объектов в С++

кратны размеру char, и по определению значение sizeof(char) тождественно 1.

В зависимости от машины значение типа char может быть знаковым

или беззнаковым целым. Конечно, значение типа unsigned char всегда

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

программы. Однако, использование unsigned char вместо char может

снизить скорость выполнения программы. Естественно, значение

типа signed char всегда знаковое.

В язык введено несколько целых, несколько беззнаковых типов

и несколько типов с плавающей точкой, чтобы программист мог полнее

использовать возможности системы команд. У многих машин

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

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

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

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

переменной. Однако, написать действительно переносимую программу,

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

основных типов выполняются следующие соотношения:

1==sizeof(char)<=sizeof(short)<=sizeof(int)<=sizeof(long)

sizeof(float)<=sizeof(double)<=sizeof(long double)

sizeof(I)==sizeof(signed I)==sizeof(unsigned I)

Здесь I может быть типа char, short, int или long. Помимо этого

гарантируется, что char представлен не менее, чем 8 разрядами, short

- не менее, чем 16 разрядами и long - не менее, чем 32 разрядами. Тип char

достаточен для представления любого символа из набора символов

данной машины. Но это означает только то, что тип char может

представлять целые в диапазоне 0..127. Предположить большее -

рискованно.

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

которых память рассматривается как массив разрядов. Но, как

правило, использование unsigned вместо int, не дает ничего хорошего,

хотя таким образом рассчитывали выиграть еще один разряд для

представления положительных целых. Описывая переменную как unsigned,

нельзя гарантировать, что она будет только положительной, поскольку

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

unsigned surprise = -1;

Это определение допустимо (хотя компилятор может выдать предупреждение

о нем).

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

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*); // из

char alpha[] = "abcdefghijklmnopqrstuvwxyz";

main()

{

int sz = strlen(alpha);

for (int i=0; i
char ch = alpha[i];

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

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

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

}

}

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

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

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

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

было использовать размер массива 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*); // из

char v[] = "Annemarie";

char* p = v;

strlen(p);

strlen(v);

}

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

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

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

Blog

* законченный учебник и руководство по языку