Побитовые логические операции

| ^ ~

применяются к целым, то есть к объектам типа char, short, int, long и их unsigned аналогам, результаты тоже целые.

Одно из стандартных применений побитовых логических операций - реализация маленького множества (вектора битов). В этом случае каждый бит беззнакового целого представляет один член множества, а число членов ограничено числом битов. Бинарная операция интерпретируется как пересечение, | как объединение, а ^ как разность. Для именования членов такого множества можно использовать перечисление. Вот маленький пример, заимствованный из реализации (не пользовательского интерфейса) :

enum state_value { _good=0, _eof=1, _fail=2, _bad=4}; // хорошо, конец файла, ошибка, плохо

Определение _good не является необходимым. Я просто хотел, чтобы состояние, когда все в порядке, имело подходящее имя. Состояние потока можно установить заново следующим образом:

cout.state = _good;

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

if (cout.state(_bad|_fail)) // не good

Еще одни скобки необходимы, поскольку имеет более высокий приоритет, чем |.

Функция, достигающая конца ввода, может сообщать об этом так:

cin.state |= _eof;

Операция |= используется потому, что поток уже может быть испорчен (то есть, state==_bad), поэтому

cin.state = _eof;

очистило бы этот признак. Различие двух потоков можно находить так:

state_value diff = cin.state^cout.state;

В случае типа stream_state (состояние потока) такая разность не очень нужна, но для других похожих типов она оказывается самой полезной. Например, при сравнении вектора бит, представляющего множество прерываний, которые обрабатываются, с другим, представляющим прерывания, ждущие обработки.

Следует заметить, что использование полей (#2.5.1) в действительности является сокращенной записью сдвига и маскирования для извлечения полей бит из слова. Это, конечно, можно сделать и с помощью побитовых логических операций, Например, извлечь средние 16 бит из 32-битового int можно следующим образом:

unsigned short middle(int a) { return (a8)0xffff }

Не путайте побитовые логические операции с логическими операциями:

Последние возвращают 0 или 1, и они главным образом используются для записи проверки в операторах if, while или for (#3.3.1). Например, !0 (не ноль) есть значение 1, тогда как ~0 (дополнение нуля) есть набор битов все-единицы, который обычно является значением -1.

Полиморфные Вектора

У вас есть другая возможность - определить ваш векторный и другие вмещающие классы через указатели на объекты некоторого класса:

class common { //... }; class vector { common** v; //... public: cvector(int); common* elem(int); common* operator[](int); //... };

Заметьте, что поскольку в таких векторах хранятся указатели, а не сами объекты, объект может быть "в" нескольких таких векторах одновременно. Это очень полезное свойство подобных вмещающих классов, таких, как вектора, связанные списки, множества и т.д. Кроме того, можно присваивать указатель на производный класс указателю на его базовый класс, поэтому можно использовать приведенный выше cvector для хранения указателей на объекты всех производных от common классов. Например:

class apple : public common { /*...*/ } class orange : public common { /*...*/ } class apple_vector : public cvector { public:

cvector fruitbowl(100); //... apple aa; orange oo; //... fruitbowl[0] = aa fruitbowl[1] = oo }

Однако, точный тип объекта, вошедшего в такой вмещающий класс, больше компилятору не известен. Например, в предыдущем примере вы знаете, что элемент вектора является common, но является он apple или orange? Обычно точный тип должен в последствие быть восстановлен, чтобы обеспечить правильное использование объекта. Для этого нужно или в какой-то форме хранить информацию о типе в самом объекте, или обеспечить, чтобы во вмещающий класс помещались только объекты данного типа. Последнее легко достигается с помощью производного класса. Вы можете, например, создать вектор указателей на apple:

class apple_vector : public cvector { public: apple* elem(int i) { return (apple*) cvector::elem(i); } //... };

используя запись приведения к типу (тип)выражение, чтобы преобразовать common* (ссылку на указатель на common), которую возвращает cvector::elem, в apple*. Такое применение производных классов создает альтернативу обобщенным классам. Писать его немного труднее (если не использовать макросы таким образом, чтобы производные классы фактически реализовывали обобщенные классы; см. ), но оно имеет то преимущество, что все производные классы совместно используют единственную копию функции базового класса. В случае обобщенных классов, таких, как vector(type), для каждого нового используемого типа должна создаваться (с помощью implement()) новая копия таких функций. Другой способ, хранение идентификации типа в каждом объекте, приводит нас к стилю программирования, который часто называют объекто-основанным или объектно-ориентированным.

Поля

Использование char для представления двоичной переменной, например, переключателя включено/выключено, может показаться экстравагантным, но char является наименьшим объектом, который в C++ может выделяться независимо. Можно, однако, сгруппировать несколько таких крошечных переменных вместе в виде полей struct. Член определяется как поле путем указания после его имени числа битов, которые он занимает. Допустимы неименованные поля; они не влияют на смысл именованных полей, но неким машинно-зависимым образом могут улучшить размещение:

struct sreg { unsigned enable : 1; unsigned page : 3; unsigned : 1; // неиспользуемое unsigned mode : 2; unsigned : 4: // неиспользуемое unsigned access : 1; unsigned length : 1; unsigned non_resident : 1; }

Получилось размещение регистра 0 состояния DEC PDP11/45 (в предположении, что поля в слове размещаются слева направо). Этот пример также иллюстрирует другое основное применение полей: именовать части внешне предписанного размещения. Поле должно быть целого типа и используется как другие целые, за исключением того, что невозможно взять адрес поля. В ядре операционной системы или в отладчике тип sreg можно было бы использовать так:

sreg* sr0 = (sreg*)0777572; //... if (sr-access) { // нарушение доступа // чистит массив sr-access = 0; }

Однако применение полей для упаковки нескольких переменных в один байт не обязательно экономит пространство. Оно экономит пространство, занимаемое данными, но объем кода, необходимого для манипуляции этими переменными, на большинстве машин возрастает. Известны программы, которые значительно сжимались, когда двоичные переменные преобразовывались из полей бит в символы! Кроме того, доступ к char или int обычно намного быстрее, чем доступ к полю. Поля - это просто удобная и краткая запись для применения логических операций с целью извлечения информации из части слова или введения информации в нее.

Поля бит

Описатель члена вида

идентификатор opt: константное_выражение

определяет поле; его длина отделяется от имени поля двоеточием. Поля упаковываются в машинные целые; они не являются альтернативой слов. Поле , не влезающее в оставшееся в целом место, помещается в следующее слово. Поле не может быть шире слова. На некоторых машинах они размещаются справа налево, а на некоторых слева направо; см.

Неименованные поля полезны при заполнении для согласования внешне предписанных размещений (форматов). В особых случаях неименованные поля длины 0 задают выравнивание следующего поля по границе слова. Не требуется аппаратной поддержки любых полей, кроме целых. Более того, даже целые поля могут рассматриваться как unsigned. По этим причинам рекомендуется описывать поля как unsigned. К полям не может применяться операция получения адреса , поэтому нет указателей на поля.

Поля не могут быть членами объединения.

Поля Типа

Чтобы использовать производные классы не просто как удобную сокращенную запись в описаниях, надо разрешить следующую проблему: Если задан указатель типа base*, какому производному типу в действительности принадлежит указываемый объект? Есть три основных способа решения этой проблемы:

[1] Обеспечить, чтобы всегда указывались только объекты одного типа ();

[2] Поместить в базовый класс поле типа, которое смогут просматривать функции; и

[3] Использовать виртуальные функции (). Обыкновенно указатели на базовые классы используются при разработке контейнерных (или вмещающих) классов: множество, вектор, список и т.п. В этом случае решение 1 дает однородные списки, то есть списки объектов одного типа. Решения 2 и 3 можно использовать для построения неоднородных списков, то есть списков объектов (указателей на объекты) нескольких различных типов. Решение 3 - это специальный вариант решения 2, безопасный относительно типа.

Давайте сначала исследуем простое решение с помощью поля типа, то есть решение 2. Пример со служащими и менеджерами можно было бы переопределить так:

enum empl_type { M, E };

struct employee { empl_type type; employee* next; char* name; short department; // ... };

struct manager : employee { employee* group; short level; // уровень };

Имея это, мы можем теперь написать функцию, которая печатает информацию о каждом служащем:

void print_employee(employee* e) { switch (e-type) { case E: cout name department name department level

и воспользоваться ею для того, чтобы напечатать список служащих:

void f() { for (; ll; ll=ll-next) print_employee(ll); }

Это прекрасно работает, особенно в небольшой программе, написанной одним человеком, но имеет тот коренной недостаток, что неконтролируемым компилятором образом зависит от того, как программист работает с типами. В больших программах это обычно приводит к ошибкам двух видов. Первый - это невыполнение проверки поля типа, второй - когда не все случаи case помещаются в переключатель switch как в предыдущем примере. Оба избежать достаточно легко , когда программу сначала пишут на бумаге $, но при модификации нетривиальной программы, особенно написанной другим человеком, очень трудно избежать и того, и другого. Часто от этих сложностей становится труднее уберечься из-за того, что функции вроде print() часто бывают организованы так, чтобы пользоваться общность классов, с которыми они работают. Например:

void print_employee(employee* e) { cout name department type == M) { manager* p = (manager*)e; cout level

Отыскание всех таких операторов if, скрытых внутри большой функции, которая работает с большим числом производных классов, может оказаться сложной задачей, и даже когда все они найдены, бывает нелегко понять, что же в них делается.

Помеченные операторы

Перед любым оператором может стоять префикс метка, имеющий вид

идентификатор :

который служит для описания идентификатора как метки. Метка используется только как объект для goto. Областью видимости метки является текущая функция, исключая любой подблок, в котором был переписан такой же идентификатор. См.

Порядок вычисления

Порядок вычисления подвыражений в выражении не определен. Например

int i = 1; v[i] = i++;

может вычисляться или как v[1]=1, или как v[2]=1. При отсутствии ограничений на порядок вычисления выражения может генерироваться более хороший код. Было бы замечательно, если бы компилятор предупреждал о подобных неоднозначностях, но большинство компиляторов этого не делают.

Относительно операций

гарантируется, что их левый операнд вычисляется раньше, чем правый. Например, b=(a=2,a=1) присвоит b 3. В #3.3.1 приводятся примеры использования и . Заметьте, что операция последования , (запятая) логически отличается от запятой, которая используется для разделения параметров в вызове функции. Рассмотрим

f1(v[i],i++); // два параметра f2( (v[i],i++) ) // один параметр

В вызове f1 два параметра, v[i] и i++, и порядок вычисления выражений-параметров не определен. Зависимость выражения-параметра от порядка вычисления - это очень плохой стиль, а также непереносимо. В вызове f2 один параметр, выражение с запятой, которое эквивалентно i++.

С помощью скобок нельзя задать порядок вычисления. Например, a*(b/c) может вычисляться и как (a*b)/c, поскольку * и / имеют одинаковый приоритет. В тех случаях, когда важен порядок вычисления, можно вводить дополнительную переменную, например, (t=b/c,a*t).

Построение Производного Класса

Рассмотрим построение программы, которая имеет дело с людьми, служащими в некоторой фирме. Структура данных в этой программе может быть например такой:

struct employee { // служащий char* name; // имя short age; // возраст short department; // подразделение int salary; // employee* next; // ... };

Список аналогичных служащих будет связываться через поле next. Теперь давайте определим менеджера:

struct manager { // менеджер employee emp; // запись о менеджере как о служащем employee* group; // подчиненные люди // ... };

Менеджер также является служащим; относящиеся к служащему employee данные хранятся в члене emp объекта manager. Для читающего это человека это, может быть, очевидно, но нет ничего выделяющего член emp для компилятора. Указатель на менеджера (manager*) не является указателем на служащего (employee*), поэтому просто использовать один там, где требуется другой, нельзя. В частности, нельзя поместить менеджера в список служащих, не написав для этого специальную программу. Можно либо применить к manager* явное преобразование типа, либо поместить в список служащих адрес члена emp, но и то и другое мало элегантно и довольно неясно. Корректный подход состоит в том, чтобы установить, что менеджер является служащим с некоторой добавочной информацией:

struct manager : employee { employee* group; // ... };

manager является производным от employee и, обратно, employee есть базовый класс для manager. Класс manager дополнительно к члену group имеет члены класса employee (name, age и т.д.).

Имея определения employee и manager мы можем теперь создать список служащих, некоторые из которых являются менеджерами. Например:

void f() { manager m1, m2; employee e1, e2; employee* elist; elist = m1 // поместить m1, e1, m2 и e2 в elist m1.next = e1 e1.next = m2 m2.next = e2 e2.next = 0; }

Поскольку менеджер является служащим, manager* может использоваться как employee*. Однако служащий необязательно является менеджером, поэтому использовать employee* как manager* нельзя.

Потоки

Язык C++ не обеспечивает средств для ввода/вывода. Ему это и не нужно; такие средства легко и элегантно можно создать с помощью самого языка. Описанная здесь стандартная библиотека потокового ввода/вывода обеспечивает гибкий и эффективный с гарантией типа метод обработки символьного ввода целых чисел, чисел с плавающей точкой и символьных строк, а также простую модель ее расширения для обработки типов, определяемых пользователем. Ее пользовательский интерфейс находится в . В этой главе описывается сама библиотека, некоторые способы ее применения и методы, которые использовались при ее реализации.

Правила Правой Руки (*1)

Здесь приводится набор правил, которых вам хорошо бы придерживаться изучая C++. Когда вы станете более опытны, вы можете превратить их в то, что будет подходить для вашего рода деятельности и вашего стиля программирования. Они умышленно сделаны очень простыми, поэтому подробности в них опущены. Не воспринимайте их чересчур буквально. Написание хороших программ требует ума, вкуса и терпения. Вы не собираетесь как следует понять это с самого начала; поэкспериментируйте!

[1] Когда вы программируете, вы создаете конкретное представление идей вашего решения некоторой задачи. Пусть структура отражает эти идеи настолько явно, насколько это возможно:

[a] Если вы считайте "это" отдельным понятием, сделайте его классом.

[b] Если вы считайте "это" отдельным объектом, сделайте его объектом некоторого класса.

[c] Если два класса имеют общим нечто существенное, сделайте его базовым классом. Почти все классы в вашей программе будут иметь нечто общее; заведите (почти) универсальный базовый класс, и разработайте его наиболее тщательно.

[2] Когда вы определяете класс, который не реализует некоторый математический объект, вроде матрицы или комплексного числа, или тип низкого уровня, вроде связанного списка, то:

[a] Не используйте глобальные данные.

[b] Не используйте глобальные функции (не члены).

[c] Не используйте открытые данные-члены.

[d] Не используйте друзей, кроме как чтобы избежать [a], [b] или [c].

[e] Не обращайтесь к данным-членам или другим объектам непосредственно.

[f] Не помещайте в класс "поле типа"; используйте виртуальные функции.

[g] Не используйте inline-функции, кроме как средство существенной оптимизации.

Язык формирует наш способ мышления

" Язык формирует наш способ мышления и определяет, о чем мы можем мыслить." Б.Л. Ворф
C++ - универсальный язык программирования, задуманный так, чтобы сделать программирование более приятным для серьезного программиста. За исключением второстепенных деталей C++ является надмножеством языка программирования C. Помимо возможностей, которые дает C, C++ предоставляет гибкие и эффективные средства определения новых типов. Используя определения новых типов, точно отвечающих концепциям приложения, программист может разделять разрабатываемую программу на легко поддающиеся контролю части. Такой метод построения программ часто называют абстракцией данных. Информация о типах содержится в некоторых объектах типов, определенных пользователем. Такие объекты просты и надежны в использовании в тех ситуациях, когда их тип нельзя установить на стадии компиляции. Программирование с применением таких объектов часто называют объектно-ориентированным. При правильном использовании этот метод дает более короткие, проще понимаемые и легче контролируемые программы.

Ключевым понятием C++ является класс. Класс - это тип, определяемый пользователем. Классы обеспечивают скрытие данных, гарантированную инициализацию данных, неявное преобразование типов для типов, определенных пользователем, динамическое задание типа, контролируемое пользователем управление памятью и механизмы перегрузки операций. C++ предоставляет гораздо лучшие, чем в C, средства выражения модульности программы и проверки типов. В языке есть также усовершенствования, не связанные непосредственно с классами, включающие в себя символические константы, inline- подстановку функций, параметры функции по умолчанию, перегруженные имена функций, операции управления свободной памятью и ссылочный тип. В C++ сохранены возможности языка C по работе с основными объектами аппаратного обеспечения (биты, байты, слова, адреса и т.п.). Это позволяет весьма эффективно реализовывать типы, определяемые пользователем.

C++ и его стандартные библиотеки спроектированы так, чтобы обеспечивать переносимость. Имеющаяся на текущий момент реализация языка будет идти в большинстве систем, поддерживающих C. Из C++ программ можно использовать C библиотеки, и с C++ можно использовать большую часть инструментальных средств, поддерживающих программирование на C.

Эта книга предназначена главным образом для того, чтобы помочь серьезным программистам изучить язык и применять его в нетривиальных проектах. В ней дано полное описание C++, много примеров и еще больше фрагментов программ.

Предопределенные Значения Операций

Относительно смысла операций, определяемых пользователем, не делается никаких предположений. В частности, поскольку не предполагается, что перегруженное = реализует присваивание ее первому операнду, не делается никакой проверки, чтобы удостовериться, является ли этот операнд lvalue (#с.6).

Значения некоторых встроенный операций определены как равносильные определенным комбинациям других операций над теми же аргументами. Например, если a является int, то ++a означает a+=1, что в свою очередь означает a=a+1. Такие соотношения для определенных пользователем операций не выполняются, если только не случилось так, что пользователь сам определил их таким образом. Например, определение operator+=() для типа complex не может быть выведено из определений complex::operator+() и complex::operator=().

По историческому совпадению операции = и имеют предопределенный смысл для объектов классов. Никакого элегантного способа "не определить" эти две операции не существует. Их можно, однако, сделать недееспособными для класса X. Можно, например, описать X::operator(), не задав ее определения. Если где-либо будет браться адрес объекта класса X, то компоновщик обнаружит отсутствие определения*1. Или, другой способ, можно определить X::operator() так, чтобы вызывала ошибку во время выполнения.

Предостережение

Если x и y - объекты класса cl, то x=y в стандартном случае означает побитовое копирование y в x (см. ). Такая интерпретация присваивания может привести к изумляющему (и обычно нежелательному) результату, если оно применяется к объектам класса, для которого определены конструктор и деструктор. Например:

class char_stack { int size; char* top; char* s; public: char_stack(int sz) { top=s=new char[size=sz]; } ~char_stack() { delete s; } // деструктор void push(char c) { *top++ = c; } char pop() { return *--top; } };

void h() { char_stack s1(100); char_stack s2 = s1; // неприятность char_stack s3(99); s3 = s2; // неприятность }

Здесь конструктор char_stack::char_stack() вызывается дважды: для s1 и для s3. Для s2 он не вызывается, поскольку эта переменная инициализируется присваиванием. Однако деструктор char_stack::~char_stack() вызывается трижды: для s1, s2 и s3! Кроме того, по умолчанию действует интерпретация присваивания как побитовое копирование, поэтому в конце h() каждый из s1, s2 и s3 будет содержать указатель на вектор символов, размещенный в свободной памяти при создании s1. Не останется никакого указателя на вектор символов, выделенный при создании s3. Таких отклонений можно избежать: см.

Когда в конструкторе производится присваивание указателю this, значение this до этого присваивания не определено. Таким образом, ссылка на член до этого присваивания не определена и скорее всего приведет к катастрофе. Имеющийся компилятор не пытается убедиться в том, что присваивание указателю this происходит на всех траекториях выполнения:

mytype::mytype(int i) { if (i) this = mytype_alloc(); // присваивание членам };

откомпилируется, и при i==0 никакой объект размещен не будет.

Конструктор может определить, был ли он вызван операцией new, или нет. Если он вызван new, то указатель this на входе имеет нулевое значение, в противном случае this указывает на пространство, уже выделенное для объекта (например, на стек). Поэтому можно просто написать конструктор, который выделяет память, если (и только если) он был вызван через new. Например:

mytype::mytype(int i) { if (this == 0) this = mytype_alloc(); // присваивание членам };

Эквивалентного средства, которое позволяет деструктору решить вопрос, был ли его объект создан с помощью new, не имеется, как нет и средства, позволяющего ему узнать, вызвала ли его delete, или он вызван объектом, выходящим из области видимости. Если для пользователя это существенно, то он может сохранить где-то соответствующую информацию для деструктора. Другой способ, - когда пользователь обеспечивает, что объекты этого класса размещаются только соответствующим образом. Если удается справиться с первой проблемой, то второй способ интереса не представляет.

Если тот, кто реализует класс, является одновременно и его единственным пользователем, то имеет смысл упростить, исходя из предположений о его использовании. Когда класс разрабатывается для более широкого использования, таких допущений, как правило, лучше избегать.

Как и большая часть возможностей в языках программирования, перегрузка операций может применяться как правильно, так и неправильно. В частности, можно так воспользоваться возможность определять новые значения старых операций, что они станут почти совсем непостижимы. Представьте, например, с какими сложностями столкнется человек, читающий программу, в которой операция + была переопределена для обозначения вычитания.

Данный аппарат должен уберечь программиста/читателя от худших крайностей применения перегрузки, потому что программист предохранен от изменения значения операций для основных типов данных вроде int, а также потому, что синтаксис выражений и приоритеты операций сохраняются.

Может быть. разумно применять перегрузку операций главным образом так, чтобы подражать общепринятому применению операций. В тех случаях, когда нет общепринятой операции или имеющееся в C++ множество операций не подходит для имитации общепринятого применения, можно использовать запись вызова функции.

Преобразование типа

Бывает необходимо явно преобразовать значение одного типа в значение другого. Явное преобразование типа дает значение одного типа для данного значения другого типа. Например:

float r = float(1);

перед присваиванием преобразует целое значение 1 к значению с плавающей точкой 1.0. Результат преобразования типа не является lvalue, поэтому ему нельзя присваивать (если только тип не является ссылочным типом).

Есть два способа записи явного преобразования типа: традиционная в C запись приведения к типу (double)a и функциональная запись double(a). Функциональная запись не может применяться для типов, которые не имеют простого имени. Например, чтобы преобразовать значение к указательному типу надо или использовать запись приведения

char* p = (char*)0777;

или определить новое имя типа:

typedef char* Pchar; char* p = Pchar(0777);

По моему мнению, функциональная запись в нетривиальных случаях предпочтительна. Рассмотрим два эквивалентных примера

Pname n2 = Pbase(n1-tp)-b_name; // функциональная запись Pname n3 = ((Pbase)n2-tp)-b_name; // запись приведения к типу

Поскольку операция - имеет больший приоритет, чем приведение, последнее выражение интерпретируется как

((Pbase)(n2-tp))-b_name

С помощью явного преобразования типа к указательным типам можно сымитировать, что объект имеет совершенно произвольный тип. Например:

any_type* p = (any_type*)some_object;

позволит работать посредством p с некоторым объектом some_object как с любым типом any_type.

Когда преобразование типа не необходимо, его следует избегать. Программы, в которых используется много явных преобразований типов, труднее понимать, чем те, в которых это не делается. Однако такие программы легче понимать, чем программы, просто не использующие типы для представления понятий более высокого уровня (например, программу, которая оперирует регистром устройства с помощью сдвига и маскирования, вместо того, чтобы определить подходящую struct и оперировать ею; см. ). Кроме того, правильность явного преобразования типа часто критическим образом зависит от понимания программистом того, каким образом объекты различных типов обрабатываются в языке, и очень часто от подробностей реализации. Например:

int i = 1; char* pc = "asdf"; int* pi = i

i = (int)pc; pc = (char*)i; // остерегайтесь: значение pc может измениться // на некоторых машинах // sizeof(int)

Преобразования

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

Конструктор, получающий один параметр, определяет преобразование из типа своего параметра в тип своего класса. Такие преобразования неявно применяются дополнительно к обычным арифметическим преобразованиям. Поэтому присваивание объекту из класса X допустимо, если или присваиваемое значение является X, или если X имеет конструктор, который получает присваиваемое значение как свой единственный параметр. Аналогично конструкторы используются для преобразования параметров функции () и инициализаторов (). Например:

class X { ... X (int); }; f (X arg) { X a = 1; /* a = X (1) */ a = 2; /* a = X (2) */ f (3); /* f (X (3)) */ }

Если для класса X не найден ни один конструктор, принимающий присваиваемый тип, то не делается никаких попыток отыскать конструктор для преобразования присваиваемого типа в тип, который мог бы быть приемлем для конструкторов класса X. Например:

class X { ... X (int); }; class X { ... Y (X); };

Y a = 1; /* недопустимо: Y (X (1)) не пробуется */

Преобразования ссылок

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

Ссылка на класс может преобразовываться в ссылку на открытый базовый класс этого класса; см.

Преобразования указателей

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

	Константа 0 может преобразовываться в указатель, и гарантируется, что это значение породит указатель, отличный от указателя на любой объект.
	Указатель любого типа может преобразовываться в void*.
	Указатель на класс может преобразовываться в указатель на открытый базовый класс этого класса; см. #8.5.3.
	Имя вектора может преобразовываться в указатель на его первый элемент.
	Идентификатор, описанный как "функция, возвращающая ...", всегда, когда он не используется в позиции имени функции в вызове, преобразуется в "указатель на функцию, возвращающую ...".

Препроцессор

#define идент строка_символов #define идент( идент,...,идент ) строка символов #else #endif #if выражение #ifdef идент #ifndef идент #include "имя_файла" #include

#line константа "имя_файла" #undef идент

Прикладная Программа

Прикладная программа чрезвычайно проста. Определяется новая фигура my_shape (на печати она немного похожа на рожицу), а потом пишется главная программа, которая надевает на нее шляпу. Вначале описание my_shape:

#include "shape.h"

class myshape : public rectangle { line* l_eye; // левый глаз line* r_eye; // правый глаз line* mouth; // рот public: myshape(point, point); void draw(); void move(int, int); };

Глаза и рот - отдельные и независимые объекты, которые создает конструктор my_shape:

myshape::myshape(point a, point b) : (a,b) { int ll = neast().x-swest().x+1; int hh = neast().y-swest().y+1; l_eye = new line( point(swest().x+2,swest().y+hh*3/4),2); r_eye = new line( point(swest().x+ll-4,swest().y+hh*3/4),2); mouth = new line( point(swest().x+2,swest().y+hh/4),ll-4); }

Объекты глаза и рот порознь рисуются заново функцией shape_refresh(), и в принципе могут обрабатываться независимо из объекта my_shape, которому они принадлежат. Это один способ определять средства для иерархически построенных объектов вроде my_shape. Другой способ демонстрируется на примере носа. Никакой нос не определяется, его просто добавляет к картинке функция draw():

void myshape::draw() { rectangle::draw(); put_point(point( (swest().x+neast().x)/2,(swest().y+neast().y)/2)); }

my_shape передвигается посредством перемещения базового прямоугольника rectangle и вторичных объектов l_eye, r_eye и mouth (левого глаза, правого глаза и рта):

void myshape::move() { rectangle::move(); l_eye-move(a,b); r_eye-move(a,b); mouth-move(a,b); }

Мы можем, наконец, построить несколько фигур и немного их подвигать:

main() { shape* p1 = new rectangle(point(0,0),point(10,10)); shape* p2 = new line(point(0,15),17); shape* p3 = new myshape(point(15,10),point(27,18)); shape_refresh(); p3-move(-10,-10); stack(p2,p3); stack(p1,p2); shape_refresh(); return 0; }

Еще раз обратите внимание, как функции вроде shape_refresh() и stack() манипулируют объектами типов, определяемых гораздо позже, чем были написаны (и, может быть, откомпилированы) сами эти функции.

Результатом работы программы будет:

*********** * * * * * * * * * * * * * * * * * * *********** ***************** ************* * * * ** ** * * * * * * * * * ********* * * * *************

описывает целое i, указатель ip

В качестве примера, описание
int i; int *ip; int f (); int *fip (); int (*pfi) ();
описывает целое i, указатель ip на целое, функцию f, возвращающую целое, функцию fip , возвращающую указатель на целое, и указатель pfi на функцию, возвращающую целое. Особенно полезно сравнить последние две. Цепочка *fip() есть *(fip()), как предполагается в описании, и та же конструкция требуется в выражении, вызов функции fip, и затем косвенное использование результата через (указатель) для получения целого. В описателе (*pfi)() внешние скобки необходимы, поскольку они также входят в выражение, для указания того, что функция получается косвенно через указатель на функцию, которая затем вызывается; это возвращает целое. Функции f и fip описаны как не получающие параметров, и fip как указывающая на функцию, не получающую параметров.

Описание
const a = 10, *pc = a, *const cpc = pc; int b, *const cp = b
описывает a: целую константу, pc: указатель на целую константу, cpc: константный указатель на целую константу, b: целое и cp: константный указатель на целое. Значения a, cpc и cp не могут быть изменены после инициализации. Значение pc может быть изменено, как и объект, указываемый cp. Примеры недопустимых выражений :
a = 1; a++; *pc = 2; cp = a cpc++;
Примеры допустимых выражений :
b = a; *cp = a; pc++; pc = cpc;
Описание
fseek (FILE*,long,int);
описывает функцию, получающую три параметра специальных типов. Поскольку тип возвращаемого значения не определен, принимается, что он int (). Описание
point (int = 0,int = 0);
описывает функцию, которая может быть вызвана без параметров, с одним или двумя параметрами типа int. Например
point (1,2); point (1) /* имеет смысл point (1,0); */ point () /* имеет смысл point (0,0); */
Описание
printf (char* ... );
описывает функцию, которая может быть вызываться с различными числом и типами параметров. Например
printf ("hello, world"); printf ("a=%d b=%d",a,b); printf ("string=%s",st);
Однако, она всегда должна иметь своим первым параметром char*.

В качестве другого примера,
float fa[17], *afp[17];
описывает массив чисел с плавающей точкой и массив указателей на числа с плавающей точкой. И, наконец,
static int x3d[3][5][7];
описывает массив целых, размером 3x6x7. Совсем подробно: x3d является массивом из трех элементов; каждый из элементов является массивом из пяти элементов; каждый из последних элементов является массивом из семи целых. Появление каждое из выражений x3d, x3d[i], x3d[i][j], x3d[i][j][k] может быть приемлемо. Первые три имеют тип "массив", последний имеет тип int.

Присваивание и Инициализация

Рассмотрим очень простой класс строк string:

struct string { char* p; int size; // размер вектора, на который указывает p

string(int sz) { p = new char[size=sz]; } ~string() { delete p; } };

Строка - это структура данных, состоящая из вектора символов и длины этого вектора. Вектор создается конструктором и уничтожается деструктором. Однако, как показано в #5.10, это может привести к неприятностям. Например:

void f() { string s1(10); string s2(20); s1 = s2; }

будет размещать два вектора символов, а присваивание s1=s2 будет портить указатель на один из них и дублировать другой. На выходе из f() для s1 и s2 будет вызываться деструктор и уничтожать один и тот же вектор с непредсказуемо разрушительными последствиями. Решение этой проблемы состоит в том, чтобы соответствующим образом определить присваивание объектов типа string:

struct string { char* p; int size; // размер вектора, на который указывает p

string(int sz) { p = new char[size=sz]; } ~string() { delete p; } void operator=(string) };

void string::operator=(string a) { if (this == a) return; // остерегаться s=s; delete p; p=new char[size=a.size]; strcpy(p,a.p); }

Это определение string гарантирует, и что предыдущий пример будет работать как предполагалось. Однако небольшое изменение f() приведет к появлению той же проблемы в новом облике:

void f() { string s1(10); s2 = s1; }

Теперь создается только одна строка, а уничтожается две. К неинициализированному объекту определенная пользователем операция присваивания не применяется. Беглый взгляд на string::operator=() объясняет, почему было неразумно так делать: указатель p будет содержать неопределенное и совершенно случайное значение. Часто операция присваивания полагается на то, что ее аргументы инициализированы. Для такой инициализации, как здесь, это не так по определению. Следовательно, нужно определить похожую, но другую, функцию, чтобы обрабатывать инициализацию:

struct string { char* p; int size; // размер вектора, на который указывает p

string(int sz) { p = new char[size=sz]; } ~string() { delete p; } void operator=(string) string(string); };

void string::string(string a) { p=new char[size=a.size]; strcpy(p,a.p); }

Для типа X инициализацию тем же типом X обрабатывает конструктор X(X). Нельзя не подчеркнуть еще раз, что присваивание и инициализация - разные действия. Это особенно существенно при описании деструктора. Если класс X имеет конструктор, выполняющий нетривиальную работу вроде освобождения памяти, то скорее всего потребуется полный комплект функций, чтобы полностью избежать побитового копирования объектов:

class X { // ... X(something); // конструктор: создает объект X(X); // конструктор: копирует в инициализации operator=(X); // присваивание: чистит и копирует ~X(); // деструктор: чистит };

Есть еще два случая, когда объект копируется: как параметр функции и как возвращаемое значение. Когда передается параметр, инициализируется неинициализированная до этого переменная - формальный параметр. Семантика идентична семантике инициализации. То же самое происходит при возврате из функции, хотя это менее очевидно. В обоих случаях будет применен X(X), если он определен:

string g(string arg) { return arg; }

main() { string s = "asdf"; s = g(s); }

Ясно, что после вызова g() значение s обязано быть "asdf". Копирование значения s в параметр arg сложности не представляет: для этого надо взывать string(string). Для взятия копии этого значения из g() требуется еще один вызов string(string); на этот раз инициализируемой является временная переменная, которая затем присваивается s. Такие переменные, естественно, уничтожаются как положено с помощью string::~string() при первой возможности.

Программа синтаксического разбора

Вот грамматика языка, допускаемого калькулятором:

program: END // END - это конец ввода expr_list END

expr_list: expression PRINT // PRINT - это или '\n' или ';' expression PRINT expr_list

expression: expression + term expression - term term

term: term / primary term * primary primary

primary: NUMBER // число с плавающей точкой в C++ NAME // имя C++ за исключением '_' NAME = expression - primary ( expression )

Другими словами, программа есть последовательность строк. Каждая строка состоит из одного или более выражений, разделенных запятой. Основными элементами выражения являются числа, имена и операции *, /, +, - (унарный и бинарный) и =. Имена не обязательно должны описываться до использования.

Используемый метод синтаксического анализа обычно называется рекурсивным спуском; это популярный и простой нисходящий метод. В таком языке, как C++, в котором вызовы функций относительно дешевы, этот метод к тому же и эффективен. Для каждого правила вывода грамматики имеется функция, вызывающая другие функции. Терминальные символы (например, END, NUMBER, + и -) распознаются лексическим анализатором get_token(), а нетерминальные символы распознаются функциями синтаксического анализа expr(), term() и prim(). Как только оба операнда (под)выражения известны, оно вычисляется; в настоящем компиляторе в этой точке производится генерация кода.

Программа разбора для получения ввода использует функцию get_token(). Значение последнего вызова get_token() находится в переменной curr_tok; curr_tok имеет одно из значений перечисления token_value:

enum token_value { NAME NUMBER END PLUS='+' MINUS='-' MUL='*' DIV='/' PRINT=';' ASSIGN='=' LP='(' RP=')' }; token_value curr_tok;

В каждой функции разбора предполагается, что было обращение к get_token(), и в curr_tok находится очередной символ, подлежащий анализу. Это позволяет программе разбора заглядывать на один лексический символ (лексему) вперед и заставляет функцию разбора всегда читать на одну лексему больше, чем используется правилом, для обработки которого она была вызвана. Каждая функция разбора вычисляет "свое" выражение и возвращает значение. Функция expr() обрабатывает сложение и вычитание; она состоит из простого цикла, который ищет термы для сложения или вычитания:

double expr() // складывает и вычитает { double left = term();

for(;;) // ``навсегда`` switch(curr_tok) { case PLUS: get_token(); // ест '+' left += term(); break; case MINUS: get_token(); // ест '-' left -= term(); break; default: return left; } }

Фактически сама функция делает не очень много. В манере, достаточно типичной для функций более высокого уровня в больших программах, она вызывает для выполнения работы другие функции. Заметьте, что выражение 2-3+4 вычисляется как (2-3)+4, как указано грамматикой. Странная запись for(;;) - это стандартный способ задать бесконечный цикл; можно произносить это как "навсегда" . Это вырожденная форма оператора for; альтернатива - while(1). Выполнение оператора switch повторяется до тех пор, пока не будет найдено ни + ни -, и тогда выполняется оператор return в случае default.

Операции += и -= используются для осуществления сложения и вычитания. Можно было бы не изменяя смысла программы использовать left=left+term() и left=left-term(). Однако left+=term() и left- =term() не только короче, но к тому же явно выражают подразумеваемое действие. Для бинарной операции @ выражение x@=y означает x=x@y за исключением того, что x вычисляется только один раз. Это применимо к бинарным операциям

поэтому возможны следующие операции присваивания:

Каждая является отдельной лексемой, поэтому a+ =1 является синтаксической ошибкой из-за пробела между + и =. (% является операцией взятия по модулю; ,| и ^ являются побитовыми операциями И, ИЛИ и исключающее ИЛИ; являются операциями левого и правого сдвига). Функции term() и get_token() должны быть описаны до expr().

Как организовать программу в виде набора файлов, обсуждается в Главе 4. За одним исключением все описания в данной программе настольного калькулятора можно упорядочить так, чтобы все описывалось ровно один раз и до использования. Исключением является expr(), которая обращается к term(), которая обращается к prim(), которая в свою очередь обращается к expr(). Этот круг надо как-то разорвать; описание

double expr(); // без этого нельзя

перед prim() прекрасно справляется с этим.

Функция term() аналогичным образом обрабатывает умножение и сложение:

double term() // умножает и складывает { double left = prim();

for(;;) switch(curr_tok) { case MUL: get_token(); // ест '*' left *= prim(); break; case DIV: get_token(); // ест '/' double d = prim(); if (d == 0) return error("деление на 0"); left /= d; break; default: return left; } }

Проверка, которая делается, чтобы удостовериться в том, что нет деления на ноль, необходима, поскольку результат деления на ноль не определен и как правило является роковым. Функция error(char*) будет описана позже. Переменная d вводится в программе там, где она нужна, и сразу же инициализируется. Во многих языках описание может располагаться только в голове блока. Это ограничение может приводить к довольно скверному искажению стиля программирования и/или излишним ошибкам. Чаще всего неинициализированные локальные переменные являются просто признаком плохого стиля; исключением являются переменные, подлежащие инициализации посредством ввода, и переменные векторного или структурного типа, которые нельзя удобно инициализировать одними присваиваниями . Заметьте, что = является операцией присваивания, а == операцией сравнения.

Функция prim, обрабатывающая primary, написана в основном в том же духе, не считая того, что немного реальной работы в ней все-таки выполняется, и нет нужды в цикле, поскольку мы попадаем на более низкий уровень иерархии вызовов:

double prim() // обрабатывает primary (первичные) { switch (curr_tok) { case NUMBER: // константа с плавающей точкой get_token(); return number_value; case NAME: if (get_token() == ASSIGN) { name* n = insert(name_string); get_token(); n-value = expr(); return n-value; } return look(name-string)-value; case MINUS: // унарный минус get_token(); return -prim(); case LP: get_token(); double e = expr(); if (curr_tok != RP) return error("должна быть )"); get_token(); return e; case END: return 1; default: return error("должно быть primary"); } }

При обнаружении NUMBER (то есть, константы с плавающей точкой), возвращается его значение. Функция ввода get_token() помещает значение в глобальную переменную number_value. Использование в программе глобальных переменных часто указывает на то, что структура не совсем прозрачна, что применялась некоторого рода оптимизация. Здесь дело обстоит именно так. Теоретически лексический символ обычно состоит из двух частей: значения, определяющего вид лексемы (в данной программе token_value), и (если необходимо) значения лексемы. У нас имеется только одна простая переменная curr_tok, поэтому для хранения значения последнего считанного NUMBER понадобилась глобальная переменная number_value. Это работает только потому, что калькулятор при вычислениях использует только одно число перед чтением со входа другого.

Так же, как значение последнего встреченного NUMBER хранится в number_value, в name_string в виде символьной строки хранится представление последнего прочитанного NAME. Перед тем, как что-либо сделать с именем, калькулятор должен заглянуть вперед, чтобы посмотреть, осуществляется ли присваивание ему, или оно просто используется. В обоих случаях надо справиться в таблице имен. Сама таблица описывается в здесь надо знать только, что она состоит из элементов вида:

srtuct name { char* string; char* next; double value; }

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

name* look(char*); name* insert(char*);

Обе возвращают указатель на name, соответствующее параметру - символьной строке; look() выражает недовольство, если имя не было определено. Это значит, что в калькуляторе можно использовать имя без предварительного описания, но первый раз оно должно использоваться в левой части присваивания.

Производные классы

Теперь давайте определим вектор, для которого пользователь может задавать границы изменения индекса.

class vec: public vector { int low, high; public: vec(int,int); int elem(int); int operator[](int); };

Определение vec как

:public vector

означает, в первую очередь, что vec это vector. То есть, тип vec имеет (наследует) все свойства типа vector дополнительно к тем, что описаны специально для него. Говорят, что класс vector является базовым классом для vec, а о vec говорится, что он производный от vector.

Класс vec модифицирует класс vector тем, что в нем задается другой конструктор, который требует от пользователя указывать две границы изменения индекса, а не длину, и имеются свои собственные функции доступа elem(int) и operator[](int). Функция elem() класса vec легко выражается через elem() класса vector:

int vec::elem(int i) { return vector::elem(i-low); }

Операция разрешения области видимости :: используется для того, чтобы не было бесконечной рекурсии обращения к vec::elem() из нее самой. с помощью унарной операции :: можно ссылаться на нелокальные имена. Было бы разумно описать vec::elem() как inline, поскольку, скорее всего, эффективность существенна, но необязательно, неразумно и невозможно написать ее так, чтобы она непосредственно использовала закрытый член v класса vector. Фунции производного класса не имеют специального доступа к закрытым членам его базового класса.

Конструктор можно написать так:

vec::vec(int lb, int hb) : (hb-lb+1) { if (hb-lb

Запись : (hb-lb+1) используется для определения списка параметров конструктора базового класса vector::vector(). Этот конструктор вызывается перед телом vec::vec(). Вот небольшой пример, который можно запустить, если скомпилировать его вместе с остальными описаниями vector:

#include

void error(char* p) { cerr

Не надо размножать объекты без необходимости - У. Оккам

В этой главе описывается понятие производного класса в C++. Производные классы дают простой, гибкий и эффективный аппарат задания для класса альтернативного интерфейса и определения класса посредством добавления возможностей к уже имеющемуся классу без перепрограммирования или перекомпиляции. С помощью производных классов можно также обеспечить общий интерфейс для нескольких различных классов так, чтобы другие части программы могли работать с объектами этих классов одинаковым образом. При этом обычно в каждый объект помещается информация о типе, чтобы эти объекты могли обрабатываться соответствующим образом в ситуациях, когда их тип нельзя узнать во время компиляции. Для элегантной и надежной обработки таких динамических зависимостей типов имеется понятие виртуальной функции. По своей сути производные классы существуют для того, чтобы облегчить программисту формулировку общности.

В конструкции

агрег идентификатор:public opt typedef-имя

typedef-имя должно означать ранее описанный класс, называемый базовым классом для класса, подлежащего описанию. Говорится, что последний выводится из предшествующего. На члены базового класса можно ссылаться, как если бы они были членами производного класса, за исключением тех случаев, когда имя базового члена было переопределено в производном классе; в этом случае для ссылки на скрытое имя может использоваться такая запись (#7.1):

typedef-имя :: идентификатор

Например:

struct base { int a; int b; };

struct derived : public base { int b; int c; };

derived d;

d.a = 1; d.base::b = 2; d.b = 3; d.c = 4;

осуществляет присваивание четырем членам d.

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

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

Вот операции, создающие из основных типов новые типы:

*	указатель на
*const	константный указатель на
	ссылка на
[]	вектор
()	функция, возвращающая

Например:

char* p	// указатель на символ
char *const q	// константный указатель на символ
char v[10]	// вектор из 10 символов

Все вектора в качестве нижней границы индекса имеют ноль, поэтому в v десять элементов: v[0] ... v[9]. Функции объясняются в #1.5, ссылки в . Переменная указатель может содержать адрес объекта соответствующего типа:

char c; // ... p = c // p указывает на c

Унарное является операцией взятия адреса.

Другие типы модно выводить из основных типов (и типов, определенных пользователем) посредством операций описания:

*	указатель
	ссылка
[]	вектор
()	функция

и механизма определения структур. Например:

int* a; float v[10]; char* p[20]; // вектор из 20 указателей на символ void f(int); struct str { short length; char* p; };

Правила построения типов с помощью этих операций подробно объясняются в Основная идея состоит в том, что описание производного типа отражает его использование. Например:

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) можно использовать для указания на объекты неизвестного типа.

Проверки

Проверка значения может осуществляться или оператором if, или оператором switch:

if ( выражение ) оператор if ( выражение ) оператор else оператор switch ( выражение ) оператор

В C++ нет отдельного булевского типа. Операции сравнения

== != =

возвращают целое 1, если сравнение истинно, иначе возвращают 0. Не так уж непривычно видеть, что ИСТИНА определена как 1, а ЛОЖЬ определена как 0.

В операторе if первый (или единственный) оператор выполняется в том случае, если выражение ненулевое, иначе выполняется второй оператор (если он задан). Отсюда следует, что в качестве условия может использоваться любое целое выражение. В частности, если a целое, то

if (a) // ...

эквивалентно

if (a != 0) // ...

Логические операции

наиболее часто используются в условиях. Операции и не будут вычислять второй аргумент, если это ненужно. Например:

if (p 1count) // ...

вначале проверяет, является ли p не нулем, и только если это так, то проверяет 1count.

Некоторые простые операторы if могут быть с удобством заменены выражениями арифметического if. Например:

if (a

лучше выражается так:

max = (a

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

Некоторые простые операторы switch можно по-другому записать в виде набора операторов if. Например:

switch (val) { case 1: f(); break; case 2; g(); break; default: h(); break; }

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

if (val == 1) f(); else if (val == 2) g(); else h();

Смысл тот же, однако первый вариант (switch) предпочтительнее, поскольку в этом случае явно выражается сущность действия (сопоставление значения с рядом констант). Поэтому в нетривиальных случаях оператор switch читается легче.

Заботьтесь о том, что switch должен как-то завершаться, если только вы не хотите, чтобы выполнялся следующий case. Например:

switch (val) { // осторожно case 1: cout

при val==1 напечатает

case 1 case 2 default: case не найден

к великому изумлению непосвященного. Самый обычный способ завершить случай - это break, иногда можно даже использовать goto. Например:

switch (val) { // осторожно case 0: cout

При обращении к нему с val==2 выдаст

case 2 case 1

Заметьте, что метка case не подходит как метка для употребления в операторе goto:

goto case 1; // синтаксическая ошибка

Пустой оператор

Простейшей формой оператора является пустой оператор:

;

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

Пустой оператор имеет вид

;

Пустой оператор используется для помещения метки непосредственно перед } составного оператора или того, чтобы снабдить такие операторы, как while, пустым телом.

Работа со Строками

Можно осуществлять действия, подобные вводу/выводу, над символьным вектором, прикрепляя к нему istream или ostream. Например, если вектор содержит обычную строку, завершающуюся нулем, для печати слов из этого вектора можно использовать приведенный выше копирующий цикл:

void word_per_line(char v[], int sz) /* печатет "v" размера "sz" по одному слову на строке */ { istream ist(sz,v); // сделать istream для v char b2[MAX]; // больше наибольшего слова while (istb2) cout

Завершающий нулевой символ в этом случае интерпретируется как символ конца файла.

В помощью ostream можно отформатировать сообщения, которые не нужно печатать тотчас же:

char* p = new char[message_size]; ostream ost(message_size,p); do_something(arguments,ost); display(p);

Такая операция, как do_something, может писать в поток ost, передавать ost своим подоперациям и т.д. с помощью стандартных операций вывода. Нет необходимости делать проверку не переполнение, поскольку ost знает свою длину и когда он будет переполняться, он будет переходить в состояние _fail. И, наконец, display может писать сообщения в "настоящий" поток вывода. Этот метод может оказаться наиболее полезным, чтобы справляться с ситуациями, в которых окончательное отображение данных включает в себя нечто более сложное, чем работу с традиционным построчным устройством вывода. Например, текст из ost мог бы помещаться в располагающуюся где-то на экране область фиксированного размера.

Расширения

Типы параметров функции могут быть заданы (#8.4) и будут проверяться (). Могут выполняться преобразования типов.

Для выражений с числами с плавающей точкой может использоваться плавающая арифметика одинарной точности;

Имена функций могут быть перегружены;

Операции могут быть перегружены; #7.16, #8.5.10.

Может осуществляться inline-подстановка функций; #8.1.

Объекты данных могут быть константными (const);

Могут быть описаны объекты ссылочного типа; ,

Операции new и delete обеспечивают свободное хранение в памяти; #17.

Класс может обеспечивать скрытые данные (), гарантированную инициализацию (#8.6.2), определяемые пользователем преобразования (#8.5.6), и динамическое задание типов через использование виртуальных функций (#8.5.4).

Имя класса является именем типа; #8.5.

Любой указатель может присваиваться [указателю] void* без приведения типов;

[] []

Размышления о программировании на C++

В идеальном случае подход к разработке программы делится на три части: вначале получить ясное понимание задачи, потом выделить ключевые идеи, входящие в ее решение, и наконец выразить решение в виде программы. Однако подробности задачи и идеи решения часто становятся ясны только в результате попытки выразить их в виде программы - именно в этом случае имеет значение выбор языка программирования.

В большинстве разработок имеются понятия, которые трудно представить в программе в виде одного из основных типов или как функцию без ассоциированных с ней статических данных. Если имеется подобное понятие, опишите класс, представляющий его в программе. Класс - это тип; это значит, что он задает поведение объектов его класса: как они создаются, как может осуществляться работа с ними, и как они уничтожаются. Класс также задает способ представления объектов; но на ранних стадиях разработки программы это не является (не должно являться) главной заботой. Ключом к написанию хорошей программы является разработка таких классов, чтобы каждый из них представлял одно основное понятие. Обычно это означает, что программист должен сосредоточиться на вопросах: Как создаются объекты этого класса? Могут ли эти объекты копироваться и/или уничтожаться? Какие действия можно производить над этими объектами? Если на такие вопросы нет удовлетворительных ответов, то во-первых, скорее всего, понятие не было "ясно", и может быть неплохо еще немного подумать над задачей и предлагаемым решением вместо того, чтобы сразу начинать "программировать вокруг" сложностей.

Проще всего иметь дело с такими понятиями, которые имеют традиционную математическую форму: числа всех видов, множества, геометрические фигуры и т.п. На самом деле, следовало бы иметь стандартные библиотеки классов, представляющих такие понятия, но к моменту написания это не имело места. C++ еще молод, и его библиотеки не развились еще до той же степени, что и сам язык.

Понятие не существует в пустоте, всегда есть группы связанных между собой понятий. Организовать в программе взаимоотношения между классами, то есть определить точную взаимосвязь между различными понятиями, часто труднее, чем сначала спланировать отдельные классы. Лучше, чтобы не получилось неразберихи, когда каждый класс (понятие) зависит от всех остальных. Рассмотрим два класса, A и B. Взаимосвязи вроде "A вызывает функции из B", "A создает объекты B" и "A имеет члены B" редко вызывают большие сложности, а взаимосвязь вроде "A использует данные из B" обычно можно исключить (просто не используйте открытые данные-члены). Неприятными, как правило, являются взаимосвязи, которые по своей природе имеют вид "A есть B и ...".

Одним из наиболее мощных интеллектуальных средств, позволяющих справляться со сложностью, является иерархическое упорядочение, то есть организация связанных между собой понятий в древовидную структуру с самым общим понятием в корне. В C++ такие структуры представляются производными классами. Часто можно организовать программу как множество деревьев (лес?). То есть, программист задает набор базовых классов, каждый из которых имеет свое собственное множество производных классов. Для определения набора действий для самой общей интерпретации понятия (базового класса) часто можно использовать виртуальные функции (#7.2.8). Интерпретацию этих действий можно, в случае необходимости, усовершенствовать для отдельных специальных классов (производных классов).

Естественно, такая организация имеет свои ограничения. В частности, множество понятий иногда лучше организуется в виде ациклического графа, в котором понятие может непосредственно зависеть от более чем одного другого понятия; например, "A есть B и C и ...". В C++ нет непосредственной поддержки этого, но подобные связи можно представить, немного потеряв в элегантности и сделав малость дополнительной работы (#7.2.5).

Иногда для организации понятий некоторой программы оказывается непригоден даже ациклический граф; некоторые понятия оказываются взаимозависимыми по своей природе. Если множество взаимозависимых классов настолько мало, что его легко себе представить, то циклические зависимости не должны вызвать сложностей. Для представления множеств взаимозависимых классов с C++ можно использовать идею friend классов (#5.4.1).

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

Напомню, что большую часть программирования можно легко и очевидно выполнять, используя только простые типы, структуры данных, обычные функции и небольшое число классов из стандартной библиотеки. Весь аппарат, входящий в определение новых типов, не следует использовать за исключением тех случаев, когда он действительно нужен.

Вопрос "Как пишут хорошие программы на C++" очень похож на вопрос "Как пишут хорошую английскую прозу?" Есть два вида ответов: "Знайте, что вы хотите сказать" и "Практикуйтесь. Подражайте хорошему языку." Оба совета оказываются подходящими к C++ в той же мере, сколь и для английского - и им столь же трудно следовать.

Реализация

Реализующие slist функции в основном просты. Единственная настоящая сложность - что делать в случае ошибки, если, например, пользователь попытается get() что-нибудь из пустого списка. Мы обсудим это в Здесь приводятся определения членов slist. Обратите внимание, как хранение указателя на последний элемент кругового списка дает возможность просто реализовать оба действия append() и insert():

int slist::insert(ent a) { if (last) last-next = new slink(a,last-next); else { last = new slink(a,0); last-next = last; } return 0; }

int slist::append(ent a) { if (last) last = last-next = new slink(a,last-next); else { last = new slink(a,0); last-next = last; } return 0; }

ent slist::get() { if (last == 0) slist_handler("get fromempty list"); // взять из пустого списка slink* f = last-next; ent r f-e; if (f == last) last = 0; else last-next = f-next; delete f; return f; }

Обратите внимание, как вызывается slist_handler (его описание можно найти в ). Этот указатель на имя функции используется точно так же, как если бы он был именем функции. Это является краткой формой более явной записи вызова:

(*slist_handler)("get fromempty list");

И slist::clear(), наконец, удаляет из списка все элементы:

void slist::clear() { slink* l = last; if (l == 0) return; do { slink* ll = l; l = l-next; delete ll; } while (l!=last); }

Класс slist не обеспечивает способа заглянуть в список, но только средства для вставления и удаления элементов. Однако оба класса, и slist, и slink, описывают класс slist_iterator как друга, поэтому мы можем описать подходящий итератор. Вот один, написанный в духе :

class slist_iterator { slink* ce; slist* cs; public: slist_iterator(slist s) { cs = s ce = cs-last; }

ent operator()() { // для индикации конца итерации возвращает 0 // для всех типов не идеален, хорош для указателей ent ret = ce ? (ce=ce-next)-e : 0; if (ce == cs-last) ce= 0; return ret; } };

Регистры

Во многих машинных архитектурах можно обращаться к (небольшим) объектам заметно быстрее, когда они помещены в регистр. В идеальном случае компилятор будет сам определять оптимальную стратегию использования всех регистров, доступных на машине, для которой компилируется программа. Однако это нетривиальная задача, поэтому иногда программисту стоит дать подсказку компилятору. Это делается с помощью описания объекта как register. Например:

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

Невозможно получить адрес имени, описанного как register, регистр не может также быть глобальным.

Символьные Константы

Хотя в C++ и нет отдельного символьного типа данных, точнее, символ может храниться в целом типе, в нем для символов имеется специальная и удобная запись. Символьная константа - это символ, заключенный в одинарные кавычки; например, 'a' или '0'. Такие символьные константы в действительности являются символическими константами для целого значения символов в наборе символов той машины, на которой будет выполняться программа (который не обязательно совпадает с набором символов, применяемом на том компьютере, где программа компилируется). Поэтому, если вы выполняетесь на машине, использующей набор символов ASCII, то значением '0' будет 48, но если ваша машина использует EBCDIC, то оно будет 240. Употребление символьных констант вместо десятичной записи делает программу более переносимой. Несколько символов также имеют стандартные имена, в которых обратная косая \ используется как escape-символ:

'\b'	возврат назад
'\f'	перевод формата
'\n'	новая строка
'\r'	возврат каретки
'\t'	горизонтальная табуляция
'\v'	вертикальная табуляция
'\\'	обратная косая (обратный слэш)
'\''	одинарная кавычка
'\"'	двойная кавычка
'\0'	null, пустой символ, целое значение 0

Вопреки их внешнему виду каждое является одним символом. Можно также представлять символ одно-, дву- или трехзначным восьмеричным числом (символ \, за которым идут восьмеричные цифры), или одно-, дву- или трехзначным шестнадцатиричным числом (\x, за которым идут шестнадцатиричные цифры). Например:

'\6' '\x6' 6 ASCII ack '\60' '\x30' 48 ASCII '0' '\137' '\x05f' 95 ASCII '_'

Это позволяет представлять каждый символ из машинного набора символов, и в частности вставлять такие символы в символьные строки (см. следующий раздел). Применение числовой записи для символов делает программу непереносимой между машинами с различными наборами символов.

Символьная константа состоит из символа, заключенного в одиночные кавычки (апострофы), как, например, 'х'. Значением символьной константы является численное значение символа в машинном наборе символов (алфавите). Символьные константы считаются данными типа int.

Некоторые неграфические символы, одиночная кавычка ' и обратная косая \, могут быть представлены в соответствие со следующей таблицей escape-последовательностей:

символ новой строки	NL(LF)	\n
горизонтальная табуляция	NT	\t
вертикальная табуляция	VT	\v
возврат на шаг	BS	\b
возврат каретки	CR	\r
перевод формата	FF	\f
обратная косая	\	\\
одиночная кавычка (апостроф)	'	\'
набор битов	dd	\ddd
набор битов	ddd	\xddd

Escape-последовательность \ddd состоит из обратной косой, за которой следуют 1, 2 или 3 восьмеричных цифры, задающие значение требуемого символа. Специальным случаем такой конструкции является \0 (не следует ни одной цифры), задающая пустой символ NULL. Escape-последовательность \xddd состоит из обратной косой, за которой следуют 1, 2 или 3 шестнадцатиричных цифры, задающие значение требуемого символа. Если следующий за обратной косой символ не является одним из перечисленных, то обратная косая игнорируется.

Символы и целые

Символ или короткое целое могут использоваться, если может использоваться целое. Во всех случаях значение преобразуется к целому. Преобразование короткого целого к длинному всегда включает в себя знаковое расширение; целые являются величинами со знаком. Содержат символы знаковый разряд или нет, является машинно зависимым; см. . Более явный тип unsigned char ограничивает изменение значения от 0 до машинно зависимого максимума.

В машинах, где символы рассматриваются как имеющие знак (знаковые), символы множества кода ASCII являются положительными. Однако, символьная константа, заданная восьмеричной esc- последовательностью подвергается знаковому расширению и может стать отрицательным числом; так например, '\377' имеет значение -1.

Когда длинное целое преобразуется в короткое или в char, оно урезается влево; избыточные биты просто теряются.

Синтаксис оператора

оператор: описание {список_операторов opt} выражение opt

if ( выражение ) опреатор if ( выражение ) оператор else оператор switch ( выражение ) оператор

while ( выражение ) оператор do оператор while (выражение) for ( оператор выражение opt ; выражение opt ) оператор

case константное_выражение : оператор default : оператор break ; continue ;

return выражение opt ;

goto идентификатор ; идентификатор : оператор

список_операторов: оператор оператор список_операторов

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

Sizeof

Операция sizeof дает размер операнда в байтах. (Байт не определяется языком иначе, чем через значение sizeof. Однако, во всех существующих реализациях байт есть пространство, необходимое для хранения char.) При применении к массиву результатом является полное количество байтов в массиве. Размер определяется из описаний объектов, входящих в выражение. Семантически это выражение является беззнаковой константой и может быть использовано в любом месте, где требуется константа.

Операцию sizeof можно также применять к заключенному в скобки имени типа. В этом случае она дает размер, в байтах, объекта указанного типа.

Скрытие Данных

Используя заголовочные файлы пользователь может определять явный интерфейс, чтобы обеспечить согласованное использование типов в программе. С другой стороны, пользователь может обойти интерфейс, задаваемый заголовочным файлом, вводя в .c файлы описания extern.

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

// file1.c: // "extern" не используется int a = 7; const c = 8; void f(long) { /* ... */ }

// file2.c: // "extern" в .c файле extern int a; extern const c; extern f(int); int g() { return f(a+c); }

Поскольку описания extern в file2.c не включаются вместе с определениями в файле file1.c, компилятор не может проверить согласованность этой программы. Следовательно, если только загрузчик не окажется гораздо сообразительнее среднего, две ошибки в этой программе останутся, и их придется искать программисту.

Пользователь может защитить файл от такой недисциплинированной компоновки, описав имена, которые не предназначены для общего пользования, как static, чтобы их областью видимости был файл, и они были скрыты от остальных частей программы. Например:

// table.c: определения таблицы имен

#include "error.h" #include #include "table.h"

const TBLSZ = 23; static name* table[TBLSZ];

name* look(char* p; int ins) { /* ... */ }

Это гарантирует, что любой доступ к table действительно будет осуществляться именно через look(). "Прятать" константу TBLSZ не обязательно.

Смысл описателей

Каждый описатель считается утверждением того, что если в выражении возникает конструкция, имеющая ту же форму, что и описатель, то она дает объект указанного типа и класса памяти. Каждый описатель содержит ровно одно оп_имя; оно определяет описываемый идентификатор. За исключением описаний некоторых специальных функций (см. ) , оп_имя будет простым идентификатором.

Если в качестве описателя возникает ничем не снабженный идентификатор, то он имеет тип, указанный спецификатором, возглавляющим описание.

Описатель в скобках эквивалентен описателю без скобок, но связку сложных описателей скобки могут изменять.

Теперь представим себе описание

T D1

где T - спецификатор типа (как int и т.д.), а D1 - описатель. Допустим, что это описание заставляет идентификатор иметь тип "... T", где "..." пусто, если идентификатор D1 есть просто обычный идентификатор (так что тип x в "int x" есть просто int). Тогда, если D1 имеет вид

то тип содержащегося идентификатора есть "... указатель на T."

Если D1 имеет вид

* const D

то тип содержащегося идентификатора есть "... константный указатель на T", то есть, того же типа, что и *D, но не lvalue.

Если D1 имеет вид

или

const D

то тип содержащегося идентификатора есть "... ссылка на T." Поскольку ссылка по определению не может быть lvalue, использование const излишне. Невозможно иметь ссылку на void (void).

Если D1 имеет вид

D (список_описаний_параметров)

то содержащийся идентификатор имеет тип "... функция, принимающая параметр типа список_описаний_параметров и возвращающая T."

список_описаний_параметров: список_описаний_парам opt ... opt

список_описаний_парам: список_описаний_парам , описание_параметра описание_параметра

описание_параметра: спецификаторы_описания описатель спецификаторы_описания описатель = выражение спецификаторы_описания абстракт_описатель спецификаторы_описания абстракт_описатель = выражение

Если список_описаний_параметров заканчивается многоточием, то о числе параметров известно лишь, что оно равно или больше числа специфицированных типов параметров; если он пуст, то функция не получает ни одного параметра. Все описания для функции должны согласовываться и в типе возвращаемого значения, а также в числе и типе параметров.

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

Идентификатор может по желанию быть задан как имя параметра. Если он присутствует в описании функции, его использовать нельзя, поскольку он сразу выходит из области видимости. Если он присутствует в определении функции (#10), то он именует формальный параметр.

Если D1 имеет вид

D[ константное_выражение]

или

D[]

то тип содержащегося идентификатора есть "... массив объектов типа T". В первом случае константное_выражение есть выражение, значение которого может быть определено во время компиляции, и тип которого int. (Константные выражения определены в ) Если подряд идут несколько спецификаций "массив из", то создается многомерный массив; константное выражение, определяющее границы массива, может быть опущено только для первого члена последовательности. Этот пропуск полезен, когда массив является внешним, и настоящее определение, которое резервирует память, находится в другом месте. Первое константное выражение может также быть опущено, когда за описателем следует инициализация. В этом случае используется размер, вычисленный исходя из числа начальных элементов.

Массив может быть построен из одного из основных типов, из указателей, из структуры или объединения или из другого массива (для получения многомерного массива).

Не все возможности, которые позволяет приведенный выше синтаксис, допустимы. Ограничения следующие: функция не может возвращать массив или функцию, хотя она может возвращать указатели на эти объекты; не существует массивов функций, хотя могут быть массивы указателей на функции.

Соображения Мобильности

Определенные части C++ являются машинно зависимыми по своей сути. Следующий ниже список мест возможных затруднений не претендует на полноту, но может указать на основные из них.

Как показала практика, характеристики аппаратуры в чистом виде, такие, как размер слова, свойства плавающей арифметики и целого деления, не создают особых проблем. Другие аппаратные аспекты отражаются на различных программных разработках. Некоторые из них, особенно знаковое расширение (преобразование отрицательного символа в отрицательное целое) и порядок расположения байтов в слове, являются досадными помехами, за которыми надо тщательно следить. Большинство других являются всего лишь мелкими сложностями.

Число регистровых переменных, которые фактически могут быть помещены в регистры, различается от машины к машине, как и множество фактических типов. Тем не менее, все компиляторы на "своей" машине все делают правильно; избыточные или недействующие описания register игнорируются.

Некоторые сложности возникают при использовании двусмысленной манеры программирования. Писать программы, зависящие от какой-либо из этих особенностей, районе неблагоразумно.

В языке не определен порядок вычисления параметров функции. На некоторых машинах он слева направо, а на некоторых справа налево. Порядок появления некоторых побочных эффектов также недетерминирован.

Поскольку символьные константы в действительности являются объектами типа int, то могут быть допустимы многосимвольные константы. Однако конкретная реализация очень сильно зависит от машины, поскольку порядок, в котором символы присваиваются слову, различается от машины к машине. На некоторых машинах поля в слове присваиваются слева направо, на других справа налево.

Эти различия невидны для отдельных программ, не позволяющих себе каламбуров с типами (например, преобразования int указателя в char указатель и просмотр памяти, на которую указывает указатель), но должны приниматься во внимание при согласовании внешне предписанных форматов памяти.

Составной оператор, или блок

Составной оператор (называемый также "блок", что эквивалентно) дает возможность использовать несколько операторов в том месте, где предполагается использование одного:

составной_оператор: { список_описаний opt список_операторов opt } список_описаний: описание описание список_описаний список_операторов: оператор оператор список_операторов

Если какой-либо из идентификаторов в списке_описаний был ранее описан, то внешнее описание выталкивается на время выполнения блока, и снова входит в силу по его окончании. Каждая инициализация auto или register переменных производится всякий раз при входе в голову блока. В блок делать передачу; в этом случае инициализации не выполняются. Инициализации переменных, имеющих класс памяти static (#4.2) осуществляются только один раз в начале выполнения программы.

Состояния Потока

Каждый поток (istream или ostream) имеет ассоциированное с ним состояние, и обработка ошибок и нестандартных условий осуществляется с помощью соответствующей установки и проверки этого состояния.

Поток может находиться в одном из следующих состояний:

enum stream_state { _good, _eof, _fail, _bad };

Если состояние _good или _eof, значит последняя операция ввода прошла успешно. Если состояние _good, то следующая операция ввода может пройти успешно, в противном случае она закончится неудачей. Другими словами, применение операции ввода к потоку, который не находится в состоянии _good, является пустой операцией. Если делается попытка читать в переменную v, и операция оканчивается неудачей, значение v должно остаться неизменным (оно будет неизменным, если v имеет один из тех типов, которые обрабатываются функциями членами istream или ostream). Отличия между состояниями _fail и _bad очень незначительно и представляет интерес только для разработчиков операций ввода. В состоянии _fail предполагается, что поток не испорчен и никакие символы не потеряны. В состоянии _bad может быть все что угодно.

Состояние потока можно проверять например так:

switch (cin.rdstate()) { case _good: // последняя операция над cin прошла успешно break; case _eof: // конец файла break; case _fail: // некоего рода ошибка форматирования // возможно, не слишком плохая break; case _bad: // возможно, символы cin потеряны break; }

Для любой переменной z типа, для которого определены операции , копирующий цикл можно написать так:

while (cinz) cout

Например, если z - вектор символов, этот цикл будет брать стандартный ввод и помещать его в стандартный вывод по одному слову (то есть, последовательности символов без пробела) на строку.

Когда в качестве условия используется поток, происходит проверка состояния потока и эта проверка проходит успешно (то есть, значение условия не ноль) только если состояние _good. В частности, в предыдущем цикле проверялось состояние istream, которое возвращает cinz. Чтобы обнаружить, почему цикл или проверка закончились неудачно, можно исследовать состояние. Такая проверка потока реализуется операцией преобразования (#6.3.2).

Делать проверку на наличие ошибок каждого ввода или вывода действительно не очень удобно, и обычно источником ошибок служит программист, не сделавший этого в том месте, где это существенно. Например, операции вывода обычно не проверяются, но они могут случайно не сработать. Парадигма потока ввода/вывода построена так, чтобы когда в C++ появится (если это произойдет) механизм обработки исключительных ситуаций (как средство языка или как стандартная библиотека) его будет легко применить для упрощения и стандартизации обработки ошибок в потоках ввода/вывода.

Спецификаторы класса памяти

Спецификаторы "класса памяти" (sc-спецификатор) это:

sc-спецификатор: auto static extern register

Описания, использующие спецификаторы auto, static и register также служат определениями тем, что они вызывают резервирование соответствующего объема памяти. Если описание extern не является определением (), то где-то еще должно быть определение для данных идентификаторов.

Описание register лучше всего представить как описание auto (автоматический) с подсказкой компилятору, что описанные переменные усиленно используются. Подсказка может быть проигнорирована. К ним не может применяться операция получения адреса .

Спецификаторы auto или register могут применяться только к именам, описанным в блоке, или к формальным параметрам. Внутри блока не может быть описаний ни статических функций, ни статических формальных параметров.

В описании может быть задан максимум один sc_спецификатор. Если в описании отсутствует sc_спецификатор, то класс памяти принимается автоматическим внутри функции и статическим вне. Исключение: функции не могут быть автоматическими.

Спецификаторы static и extern могут использоваться только для имен объектов и функций.

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

фнк-спецификатор: overload inline virtual

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

Спецификатор inline является только подсказкой компилятору, не влияет на смысл программы и может быть проигнорирован. Он используется, чтобы указать на то, что при вызове функции inline- подстановка тела функции предпочтительнее обычной реализации вызова функции. Функция ( и ), определенная внутри описания класса, является inline по умолчанию.

Спецификатор virtual может использоваться только в описаниях членов класса; см.

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

С помощью спецификатора typedef вводится имя для типа; см.

Спецификаторы Типа

Спецификаторами типов (спецификатор_типа) являются:

спецификатор_типа: простое_имя_типа class_спецификатор enum-спецификатор сложный_спецификатор_типа const

Слово const можно добавлять к любому допустимому спецификатору_типа. В остальных случаях в описании может быть дано не более одного спецификатора_типа. Объект типа const не является lvalue. Если в описании опущен спецификатор типа, он принимается int.

простое_имя_типа: char short int long unsigned float double const void

Слова long, short и unsigned можно рассматривать как прилагательные. Они могут применяться к типу int; unsigned может также применяться к типам char, short и long.

Спецификаторы класса и перечисления обсуждаются в #8.5 и соответственно.

сложный_спецификатор_типа: ключ typedef-имя ключ идентификатор

ключ: class struct union enum

Сложный спецификатор типа можно использовать для ссылки на имя класса или перечисления там, где имя может быть скрыто локальным именем. Например:

class x { ... };

void f(int x) { class x a; // ... }

Если имя класса или перечисления ранее описано не было, сложный_спецификатор_типа работает как описание_имени; см.

Список инициализаторов

Когда описанная переменная является составной (класс или массив), то инициализатор может состоять из заключенного в фигурные скобки, разделенного запятыми списка инициализаторов для членов составного объекта, в порядке возрастания индекса или по порядку членов. Если массив содержит составные подобъекты, то это правило рекурсивно применяется к членам составного подобъекта. Если инициализаторов в списке меньше, чем членов в составном подобъекте, то составной подобъект дополняется нулями.

Фигурные скобки могут опускаться следующим образом. Если инициализатор начинается с левой фигурной скобки, то следующий за ней список инициализаторов инициализирует члены составного объекта; наличие числа инициализаторов, большего, чем число членов, считается ошибочным. Если, однако, инициализатор не начинается с левой фигурной скобки, то из списка берутся только элементы, достаточные для сопоставления членам составного объекта, частью которого является текущий составной объект.

Например,

int x[] = { 1, 3, 5 };

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

float y[4][3] = { { 1, 3, 5 }, { 2, 4, 6 }, { 3, 5, 7 } };

является полностью снабженной квадратными скобками инициализацией: 1,3 и 5 инициализируют первый ряд массива y[0], а именно, y[0][2]. Аналогично, следующие две строки инициализируют y[1] и y[2]. Инициализатор заканчивается раньше, поэтому y[3] инициализируется значением 0. В точности тот же эффект может быть достигнут с помощью

float y[4][3] = { 1, 3, 5, 2, 4, 6, 3, 5, 7 };

Инициализатор для y начинается с левой фигурной скобки, но не начинается с нее инициализатор для y[0], поэтому используется три значения из списка. Аналогично, следующие три успешно используются для y[1] и следующие три для y[2].

float y[4][3] = { { 1 }, { 2 }, { 3 }, { 4 } };

инициализирует первый столбец y (рассматриваемого как двумерный массив) и оставляет остальные элементы нулями.

Справочное руководство по С++










Оператор return
Оператор goto
Помеченные операторы
Пустой оператор
Оператор delete
Оператор asm

.1 Определения функций
.2 Определения внешних данных

.1 Замена идентификаторов
.2 Включение файлов
.3 Условная компиляция
.4 Управление строкой

.1 Классы
.2 Функции
.3 Массивы, указатели и индексирование
.4 Явные преобразования указателей

.1 Выражения
.2 Описания
.3 Операторы
.4 Внешние определения
.5 Препроцессор

.1 Расширения

[] [] []

Ссылки

Ссылка является другим именем объекта. Главное применение ссылок состоит в спецификации операций для типов, определяемых пользователем; они обсуждаются в Главе 6. Они могут также быть полезны в качестве параметров функции. Запись x означает ссылка на x. Например:

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

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

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

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

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

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

[1] Во-первых, если необходимо, применяются преобразование типа (, #с.8.5.6);

[2] Затем полученное значение помещается во временную переменную; и

[3] Наконец, ее адрес используется в качестве значения инициализатора.

Рассмотрим описание

double dr = 1;

Это интерпретируется так:

double* drp; // ссылка, представленная как указатель double temp; temp = double(1); drp = temp

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

int x = 1; void incr(int aa) { aa++; } incr(x) // x = 2

По определению семантика передачи параметра та же, что семантика инициализации, поэтому параметр aa функции incr становится другим именем для x. Однако, чтобы сделать программу читаемой, в большинстве случаев лучше всего избегать функций, которые изменяют значение своих параметров. Часто предпочтительно явно возвращать значение из функции или требовать в качестве параметра указатель:

int x = 1; int next(int p) { return p+1; } x = next(x); // x = 2

void inc(int* p) { (*p)++; } inc(x); // x = 3

Ссылки также можно применять для определения функций, которые могут использоваться и в левой, и в правой части присваивания. Опять, большая часть наиболее интересных случаев этого обнаруживается в проектировании нетривиальных определяемых пользователем типов. Для примера давайте определим простой ассоциативный массив. Вначале мы определим структуру пары следующим образом:

struct pair { char* name; int val; };

Основная идея состоит в том, что строка имеет ассоциированное с ней целое значение. Легко определить функцию поиска find(), которая поддерживает структуру данных, состоящую из одного pair для каждой отличной от других строки, которая была ей представлена. Для краткости представления используется очень простая (и неэффективная) реализация:

const large = 1024; static pair vec[large+1};

pair* find(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(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 MAX = 256; // больше самого большого слова

main() // подсчитывает число вхождений каждого слова во вводе { char buf[MAX];

while (cinbuf) value(buf)++;

for (int i=0; vec[i].name; i++) cout

На каждом проходе цикл считывает одно слово из стандартной строки ввода cin в buf (см. ), а затем обновляет связанный с ней счетчик с помощью find(). И, наконец, печатается полученная таблица различных слов во введенном тексте, каждое с числом его встречаемости. Например, если вводится

aa bb bb aa aa bb aa aa

то программа выдаст:

aa: 5 bb: 3

Легко усовершенствовать это в плане собственного типа ассоциированного массива с помощью класса с перегруженной операцией () выбора [].

Ссылки на Себя

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

class x { int m; public: int readm() { return m; } };

x aa; x bb;

void f() { int a = aa.readm(); int b = bb.readm(); // ... }

В первом вызове члена member() m относится к aa.m, а во втором - к bb.m.

Указатель на объект, для которого вызвана функция член, является скрытым параметром функции. На этот неявный параметр можно ссылаться явно как на this. В каждой функции класса x указатель this неявно описан как

x* this;

и инициализирован так, что он указывает на объект, для которого была вызвана функция член. this не может быть описан явно, так как это ключевое слово. Класс x можно эквивалентным образом описать так:

class x { int m; public: int readm() { return this-m; } };

При ссылке на члены использование this излишне. Главным образом this используется при написании функций членов, которые манипулируют непосредственно указателями. Типичный пример этого - функция, вставляющая звено в дважды связанный список:

class dlink { dlink* pre; // предшествующий dlink* suc; // следующий public: void append(dlink*); // ... };

void dlink::append(dlink* p) { p-suc = suc; // то есть, p-suc = this-suc p-pre = this; // явное использование this suc-pre = p; // то есть, this-suc-pre = p suc = p; // то есть, this-suc = p }

dlink* list_head;

void f(dlink*a, dlink *b) { // ... list_head-append(a); list_head-append(b); }

Цепочки такой общей природы являются основой для списковых классов, которые описываются в Главе 7. Чтобы присоединить звено к списку необходимо обновить объекты, на которые указывают указатели this, pre и suc (текущий, предыдущий и последующий). Все они типа dlink, поэтому функция член dlink::append() имеет к ним доступ. Единицей защиты в C++ является class, а не отдельный объект класса.

Статическая Память

Рассмотрим следующее:

table tbl1(100);

void f() { static table tbl2(200); }

main() { f(); }

Здесь конструктор table::table(), определенный в #5.3.1 , будет вызываться дважды: один раз для tbl1 и один раз для tbl2. Деструктор table::~table() также будет вызван дважды: для уничтожения tbl1 и tbl2 после выхода из main(). Конструкторы для глобальных статических объектов в файле выполняются в том порядке, в котором встречаются описания; деструкторы вызываются в обратном порядке. Не определено, вызывается ли конструктор для локального статического объекта, если функция, в которой этот объект описан, не вызывается. Если конструктор для локального статического объекта вызывается, то он вызывается после того, как вызваны конструкторы для лексически предшествующих ему глобальных статических объектов.

Параметры конструкторов для статических объектов должны быть константными выражениями:

void g(int a) { static table t(a); // ошибка }

Традиционно выполнение main() считалось выполнением программы. Так никогда не было, даже в C, но только размещение статических объектов класса с конструктором и/или деструктором дают программисту простой и очевидный способ задания того, что будет выполняться до и/или после вызова main().

Вызов конструкторов и деструкторов для статических объектов играет в C++ чрезвычайно важную роль. Это способ обеспечить надлежащую инициализацию и очистку структур данных в библиотеках. Рассмотрим . Откуда берутся cin, cout и cerr? Где они получают инициализацию? И, что самое главное, поскольку потоки вывода имеют внутренние буферы символов, как же эти буферы становятся заполненными? Простой и очевидный ответ, что эта работа осуществляется соответствующими конструкторами и деструкторами до и после выполнения main(). Для инициализации и очистки библиотечных средств есть возможности, альтернативные использованию конструкторов и деструкторов. Все они или очень специальные, или очень уродливые.

Если программа завершается с помощью функции exit(), то деструкторы для статических объектов будут вызваны, а если она завершается с помощью abort(), то не будут. Заметьте, что это подразумевает, что exit() не завершает программу мгновенно. Вызов exit() в деструкторе может привести к бесконечной рекурсии.

Иногда, когда вы разрабатываете библиотеку, необходимо или просто удобно создать тип с конструктором и деструктором, предназначенными только для одного: инициализировать и очистить. Такой тип обычно используется только с одной целью, для размещения статического объекта так, чтобы вызывались конструктор и деструктор.

Статические Члены

Класс - это тип, а не объект данных, и в каждом объекте класса имеется своя собственная копия данных, членов этого класса. Однако некоторые типы наиболее элегантно реализуются, если все объекты этого типа могут совместно использовать (разделять) некоторые данные. Предпочтительно, чтобы такие разделяемые данные были описаны как часть класса. Например, для управления задачами в операционной системе или в ее модели часто бывает полезен список всех задач:

class task { // ... task* next; static task* task_chain; void shedule(int); void wait(event); // ... };

Описание члена task_chain (цепочка задач) как static обеспечивает, что он будет всего лишь один, а не по одной копии на каждый объект task. Он все равно остается в области видимости класса task, и "извне" доступ к нему можно получить, только если он был описан как public. В этом случае его имя должно уточняться именем его класса:

task::task_chain

В функции члене на него можно ссылаться просто task_chain. Использование статических членов класса может заметно снизить потребность в глобальных переменных.

Член-данные класса может быть static; члены-функции не могут. Члены не могут быть auto, register или extern. Есть единственная копия статического члена, совместно используемая всеми членами класса в программе. На статический член mem класса cl можно ссылаться cl:mem, то есть без ссылки на объект. Он существует, даже если не было создано ни одного объекта класса cl.

Строки

Строковая константа - это последовательность символов, заключенная в двойные кавычки:

"это строка"

Каждая строковая константа содержит на один символ больше, чем кажется; все они заканчиваются пустым символом '\0' со значением 0. Например:

sizeof("asdf")==5;

Строка имеет тип "вектор из соответствующего числа символов", поэтому "asdf" имеет тип char[5]. Пустая строка записывается "" (и имеет тип char[1]). Заметьте, что для каждой строки s strlen(s)==sizeof(s)-1, поскольку strlen() не учитывает завершающий 0.

Соглашение о представлении неграфических символов с обратной косой можно использовать также и внутри строки. Это дает возможность представлять в строке двойные кавычки и escape-символ \. Самым обычным символом этого рода является, безусловно, символ новой строки '\n'. Например:

cout

где 7 - значение ASKII символа bel (звонок).

В строке невозможно иметь "настоящую" новую строку:

"это не строка, а синтаксическая ошибка"

Однако в строке может стоять обратная косая, сразу после которой идет новая строка; и то, и другое будет проигнорировано. Например:

cout

напечатает

здесь все ok

Новая строка, перед которой идет escape (обратная косая), не приводит к появлению в строке новой строки, это просто договоренность о записи.

В строке можно иметь пустой символ, но большинство программ не будет предполагать, что есть символы после него. Например, строка "asdf\000hjkl" будет рассматриваться стандартными функциями, вроде strcpy() и strlen(), как "asdf".

Вставляя численную константу в строку с помощью восьмеричной или шестнадцатиричной записи благоразумно всегда использовать число из трех цифр. Читать запись достаточно трудно и без необходимости беспокоиться о том, является ли символ после константы цифрой или нет. Разберите эти примеры:

char v1[] = "a\x0fah\0129"; // 'a' '\xfa' 'h' '\12' '9' char v2[] = "a\xfah\129"; // 'a' '\xfa' 'h' '\12' '9' char v3[] = "a\xfad\127"; // 'a' '\xfad' '\127'

Имейте в виду, что двузначной шестнадцатиричной записи на машинах с 9-битовым байтом будет недостаточно.

Строка есть последовательность символов, заключенная в двойные кавычки: "...". Строка имеет тип "массив символов" и класс памяти static (см. ), она инициализируется заданными символами. Все строки, даже если они записаны одинаково, различны. Компилятор располагает в конце каждой строки нулевой (пустой) байт \0 с тем, чтобы сканирующая строку программа могла найти ее конец. В строке перед символом двойной кавычки " обязательно должен стоять \; кроме того, могут использоваться те же escape-последовательности, что были описаны для символьных констант. И, наконец, символ новой строки может появляться только сразу после \; тогда оба, - \ и символ новой строки, - игнорируются.

Структура этой книги

- это короткое турне по основным особенностям C++, предназначенное для того, чтобы дать читателю почувствовать язык. Программисты на C первую половину главы могут прочитать очень быстро; она охватывает главным образом черты, общие для C и C++. Во второй главе описаны средства определения новых типов в C++; начинающие могут отложить более подробное изучение этого до того, как прочтут Главы 2, и 4.

В Главах , и описываются средства C++, не включенные в определение новых типов: основные типы, выражения и структуры управления в C++ программах. Другими словами, в них описывается подмножество C++, которое по существу является языком C. Рассмотрение в них проводится гораздо подробнее, но полную информацию можно найти только в справочном руководстве.

В Главах , и описываются средства C++ по описанию новых типов, особенности языка, не имеющие эквивалента в C. В приводится понятие базового класса, и показывается, как можно инициализировать объекты типа, определенного пользователем, обращаться к ним и, наконец, убирать их. В объясняется, как для определенного пользователем типа определять унарные и бинарные операции, как задавать преобразования между типами, определенными пользователем, и как задавать то, каким образом должно обрабатываться каждое создание, уничтожение и копирование значения определенного пользователем типа. Глава 7 описывает концепцию производных классов, которая позволяет программисту строить более сложные классы из более простых, обеспечивать альтернативные интерфейсы класса и работать с объектами безопасным и не требующим беспокоиться о типе способом в тех ситуациях, когда типы объектов не могут быть известны на стадии компиляции.

В представлены классы ostream и istream, предоставляемые стандартной библиотекой для осуществления ввода-вывода. Эта глава имеет двоякую цель: в ней представлены полезные средства, что одновременно является реальным примером использования C++.

И, наконец, в книгу включено справочное руководство по C++.

Ссылки на различные части этой книги даются в форме #2.3.4 (Глава 2 подраздел 3.4). Глава с - это справочное руководство; например, #с.8.5.5.

Структура программы

Программа на C++ обычно состоит из большого числа исходных файлов, каждый из которых содержит описания типов, функций, переменных и констант. Чтобы имя можно было использовать в разных исходных файлах для ссылки на один и тот же объект, оно должно быть описано как внешнее. Например:

extern double sqrt(double); extern instream cin;

Самый обычный способ обеспечить согласованность исходных файлов - это поместить такие описания в отдельные файлы, называемые заголовочными (или хэдер) файлами, а затем включить, то есть скопировать, эти заголовочные файлы во все файлы, где нужны эти описания. Например, если описание sqrt хранится в заголовочном файле для стандартных математических функций math.h, и вы хотите извлечь квадратный корень из 4, можно написать:

#include //... x = sqrt(4);

Поскольку обычные заголовочные файлы включаются во многие исходные файлы, они не содержат описаний, которые не должны повторяться. Например, тела функций даются только для inline-подставляемых функций () и инициализаторы даются только для констант (#1.3.1). За исключением этих случаев, заголовочный файл является хранилищем информации о типах. Он обеспечивает интерфейс между отдельно компилируемыми частями программы.

В команде включения include имя файла, заключенное в угловые скобки, например , относится к файлу с этим именем в стандартном каталоге (часто это /usr/include/CC); на файлы, находящиеся в каких-либо других местах ссылаются с помощью имен, заключенных в двойные кавычки. Например:

#include "math1.h" #include "/usr/bs/math2.h"

включит math1.h из текущего пользовательского каталога, а math2.h из каталога /usr/bs.

Здесь приводится очень маленький законченный пример программы, в котором строка определяется в одном файле, а ее печать производится в другом. Файл header.h определяет необходимые типы:

// header.h

extern char* prog_name; extern void f();

В файле main.c находится главная программа:

// main.c

#include "header.h" char* prog_name = "дурацкий, но полный"; main() { f(); }

а файл f.c печатает строку:

// f.c

#include #include "header.h" void f() { cout

Скомпилировать и запустить программу вы можете например так:

$ CC main.c f.c -o silly $ silly дурацкий, но полный $

Структуры

Вектор есть совокупность элементов одного типа; 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 не является достаточным для работы с полным почтовым адресом, но в качестве примера достаточен). Обратите внимание на точку с запятой в конце; это одно из очень немногих мест в C++, где необходимо ставить точку с запятой после фигурной скобки, поэтому люди склонны забывать об этом.

Переменные типа 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 name number street town state[0]) state[1]) zip

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

address current;

address set_current(address next) { address prev = current; current = next; return prev; }

Остальные осмысленные операции, такие как сравнение (== и !=) не определены. Однако пользователь может определить эти операции; см.

Размер объекта структурного типа нельзя вычислить просто как сумму его членов. Причина этого состоит в том, что многие машины требуют, чтобы объекты определенных типов выравнивались в памяти только по некоторым зависящим от архитектуры границам (типичный пример: целое должно быть выравнено по границе слова) или просто гораздо более эффективно обрабатывают такие объекты, если они выравнены в машине. Это приводит к "дырам" в структуре. Например, (на моей машине) 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 вызвало бы к синтаксическую ошибку.

Структуры и Объединения

По определению struct - это просто класс, все члены которого общие, то есть

struct s { ...

есть просто сокращенная запись

class s { public: ...

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

Именованное объединение определяется как struct, в которой все члены имеют один и тот же адрес (см. #с.8.5.13). Если известно, что в каждый момент времени нужно только одно значение из структуры, то объединение может сэкономить пространство. Например, можно определить объединение для хранения лексических символов C компилятора:

union tok_val { char* p; // строка char v[8]; // идентификатор (максимум 8 char) long i; // целые значения double d; // значения с плавающей точкой };

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

void strange(int i) { tok_val x; if (i) x.p = "2"; else x.d = 2; sqrt(x.d); // ошибка если i != 0 }

Кроме того, объединение, определенное так, как это, нельзя инициализировать. Например:

tok_val curr_val = 12; // ошибка: int присваивается tok_val'у

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

union tok_val { char* p; // строка char v[8]; // идентификатор (максимум 8 char) long i; // целые значения double d; // значения с плавающей точкой

tok_val(char*); // должна выбрать между p и v tok_val(int ii) { i = ii; } tok_val() { d = dd; } };

Это позволяет справляться с теми ситуациями, когда типы членов могут быть разрешены по правилам для перегрузки имени функции (см. и #6.3.3). Например:

void f() { tok_val a = 10; // a.i = 10 tok_val b = 10.0; // b.d = 10.0 }

Когда это невозможно (для таких типов, как char* и char[8], int и char, и т.п.), нужный член может быть найден только посредством анализа инициализатора в ходе выполнения или с помощью задания дополнительного параметра. Например:

tok_val::tok_val(char* pp) { if (strlen(pp)

Таких ситуаций вообще-то лучше избегать.

Использование конструкторов не предохраняет от такого случайного неправильного употребления tok_val, когда сначала присваивается значение одного типа, а потом рассматривается как другой тип. Эта проблема решается встраиванием объединения в класс, который отслеживает, какого типа значение помещается:

class tok_val { char tag; union { char* p; char v[8]; long i; double d; }; int check(char t, char* s) { if (tag!=t) { error(s); return 0; } return 1; } public: tok_val(char* pp); tok_val(long ii) { i=ii; tag='I'; } tok_val(double dd) { d=dd; tag='D'; }

long ival() { check('I',"ival"); return i; } double fval() { check('D',"fval"); return d; } char* sval() { check('S',"sval"); return p; } char* id() { check('N',"id"); return v; } };

Конструктор, получающий строковый параметр, использует для копирования коротких строк strncpy(). strncpy() похожа на strcpy(), но получает третий параметр, который указывает, сколько символов должно копироваться:

tok_val::tok_val(char* pp) { if (strlen(pp)

Тип tok_val можно использовать так:

void f() { tok_val t1("short"); // короткая, присвоить v tok_val t2("long string"); // длинная строка, присвоить p char s[8]; strncpy(s,t1.id(),8); // ok strncpy(s,t2.id(),8); // проверка check() не пройдет }