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

{

cout << prog_name << '\n';

}

При запуске транслятора С++ и передаче ему необходимых

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

расширения имен для программ на С++. На машине автора трансляция и запуск

программы выглядит так:

$ CC main.c f.c -o silly

$ silly

примитивный, но законченный пример

$

Кроме раздельной трансляции концепцию модульности в С++ поддерживают

классы ($$5.4).

1.4 Поддержка абстракции данных

Поддержка программирования с абстракцией данных в основном сводится к

возможности определить набор операций (функции и операции) над типом. Все

обращения к объектам этого типа ограничиваются операциями из заданного

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

что для удобства определения и использования новых типов нужны еще

некоторые расширения языка. Хорошим примером такого расширения является

перегрузка операций.

1.4.1 Инициализация и удаление

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

для инициализации переменных этого типа. Простейшее решение - до

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

Например:

class vector

{

// ...

public:

void init ( init size ); // вызов init () перед первым

// использованием объекта vector

// ...

};

void f ()

{

vector v;

// пока v нельзя использовать

v.init ( 10 );

// теперь можно

}

Но это некрасивое и чреватое ошибками решение. Будет лучше, если

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

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

размещения и инициализации переменной совмещаются в одной (иногда ее

называют инсталляцией или просто построением). Функция инициализации

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

данного класса тем, что имеет такое же имя, как и сам класс. Если объекты

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

операция для удаления их после последнего использования. Функция удаления

в С++ называется деструктором. Деструктор имеет то же имя, что и его

класс, но перед ним стоит символ ~ (в С++ этот символ используется для

операции дополнения). Приведем пример:

class vector

{

int sz; // число элементов

int * v; // указатель на целые

public:

vector ( int ); // конструктор

~vector (); // деструктор

int& operator [] ( int index ); // операция индексации

};

Конструктор класса vector можно использовать для контроля над ошибками

и выделения памяти:

vector::vector ( int s )

{

if ( s <= 0 )

error ( "недопустимый размер вектора" );

sz = s;

v = new int [ s ]; // разместить массив из s целых

}

Деструктор класса vector освобождает использовавшуюся память:

vector::~vector ()

{

delete [] v; // освободить массив, на который

// настроен указатель v

}

От реализации С++ не требуется освобождения выделенной с помощью new

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

не требуется автоматическая "сборка мусора"). В замен этого можно без

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

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

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

применений этих функций (см., например, $$9.4).

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

Для многих типов задача управления ими сводится к построению и

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

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

к классу vector:

void f ()

{

vector v1 ( 100 );

vector v2 = v1; // построение нового вектора v2,

// инициализируемого v1

v1 = v2; // v2 присваивается v1

// ...

}

Должна быть возможность определить интерпретацию операций

инициализации v2 и присваивания v1. Например, в описании:

class vector

{

int * v;

int sz;

public:

// ...

void operator = ( const vector & ); // присваивание

vector ( const vector & ); // инициализация

};

указывается, что присваивание и инициализация объектов типа vector

должны выполняться с помощью определенных пользователем операций.

Присваивание можно определить так:

void vector::operator = ( const vector & a )

// контроль размера и копирование элементов

{

if ( sz != a.sz )

error ( "недопустимый размер вектора для =" );

for ( int i = 0; i < sz; i++ ) v [ i ] = a.v [ i ];

}

Поскольку эта операция использует для присваивания "старое значение"

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

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

vector::vector ( const vector & a )

// инициализация вектора значением другого вектора

{

sz = a.sz; // размер тот же

v = new int [ sz ]; // выделить память для массива

for ( int i = 0; i < sz; i++ ) //копирование элементов

v [ i ] = a.v [ i ];

}

В языке С++ конструктор вида T(const T&) называется конструктором

копирования для типа T. Любую инициализацию объектов типа T он выполняет с

помощью значения некоторого другого объекта типа T. Помимо явной

инициализации конструкторы вида T(const T&) используются для передачи

параметров по значению и получения возвращаемого функцией значения.

1.4.3 Шаблоны типа

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

целых чисел? Как правило, ему нужен вектор из элементов, тип которых

неизвестен создателю класса Vector. Следовательно, надо суметь определить

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

параметр, обозначающий "реальные" типы элементов:

template < class T > class Vector

{ // вектор элементов типа T

T * v;

int sz;

public:

Vector ( int s )

{

if ( s <= 0 )

error ( "недопустимый для Vector размер" );

v = new T [ sz = s ];

// выделить память для массива s типа T

}

T & operator [] ( int i );

int size () { return sz; }

// ...

};

Таково определение шаблона типа. Он задает способ получения семейства

сходных классов. В нашем примере шаблон типа Vector показывает, как можно

получить класс вектор для заданного типа его элементов. Это описание

отличается от обычного описания класса наличием начальной конструкции

template<class T>, которая и показывает, что описывается не класс, а

шаблон типа с заданным параметром-типом (здесь он используется как тип

элементов). Теперь можно определять и использовать вектора разных типов:

void f ()

{

Vector < int > v1 ( 100 ); // вектор из 100 целых

Vector < complex > v2 ( 200 ); // вектор из 200

// комплексных чисел

v2 [ i ] = complex ( v1 [ x ], v1 [ y ] );

// ...

}

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

параметрическими типами или генерическими объектами. Оно сходно с

возможностями, имеющимися в языках Clu и Ада. Использование шаблона типа

не влечет за собой каких-либо дополнительных расходов времени по сравнению

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

1.4.4 Обработка особых ситуаций

По мере роста программ, а особенно при активном использовании

библиотек появляется необходимость стандартной обработки ошибок (или, в

более широком смысле, "особых ситуаций"). Языки Ада, Алгол-68 и Clu

поддерживают стандартный способ обработки особых ситуаций.

Снова вернемся к классу vector. Что нужно делать, когда операции

индексации передано значение индекса, выходящее за границы массива?

Создатель класса vector не знает, на что рассчитывает пользователь в таком

случае, а пользователь не может обнаружить подобную ошибку (если бы мог,

то эта ошибка вообще не возникла бы). Выход такой: создатель класса

обнаруживает ошибку выхода за границу массива, но только сообщает о ней

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

Например:

class vector {

// определение типа возможных особых ситуаций

class range { };

// ...

};

Вместо вызова функции ошибки в функции vector::operator[]() можно

перейти на ту часть программы, в которой обрабатываются особые ситуации.

Это называется "запустить особую ситуацию" ("throw the exception"):

int & vector::operator [] ( int i )

{

if ( i < 0 || sz <= i ) throw range ();

return v [ i ];

}

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

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

ситуации с типом range для класса вектор (vector::range); он и будет

выполняться.

Обработчик особых ситуаций можно определить только для специального

блока:

void f ( int i )

{

try

{

// в этом блоке обрабатываются особые ситуации

// с помощью определенного ниже обработчика

vector v ( i );

// ...

v [ i + 1 ] = 7; // приводит к особой ситуации range

// ...

g (); // может привести к особой ситуации range

// на некоторых векторах

}

catch ( vector::range )

{

error ( "f (): vector range error" );

return;

}

}

Использование особых ситуаций делает обработку ошибок более

упорядоченной и понятной. Обсуждение и подробности отложим до главы 9.

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

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

преобразование числа с плавающей точкой в комплексное, которое необходимо

для конструктора complex(double), оказались очень полезными в С++.

Программист может задавать эти преобразования явно, а может полагаться на

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

и однозначны:

complex a = complex ( 1 );

complex b = 1; // неявно: 1 -> complex ( 1 )

a = b + complex ( 2 );

a = b + 2; // неявно: 2 -> complex ( 2)

Преобразования типов нужны в С++ потому, что арифметические операции

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

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

для "вычислений" (например, матрицы, строки, машинные адреса) допускает

естественное преобразование в другие типы (или из других типов).

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

complex a = 2;

complex b = a + 2; // это означает: operator + ( a, complex ( 2 ))

b = 2 + a; // это означает: operator + ( complex ( 2 ), a )

В обоих случаях для выполнения операции "+" нужна только одна функция,

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

класс complex описывается так, что для естественного и беспрепятственного

обобщения понятия числа нет необходимости что-то изменять для целых чисел.

1.4.6 Множественные реализации

Основные средства, поддерживающие объектно-ориентированное

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

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

несколько реализаций одного типа. Вернемся к примеру со стеком:

template < class T >

class stack

{

public:

virtual void push ( T ) = 0; // чистая виртуальная функция

virtual T pop () = 0; // чистая виртуальная функция

};

Обозначение =0 показывает, что для виртуальной функции не требуется

никакого определения, а класс stack является абстрактным, т.е. он может

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

но не создавать:

class cat { /* ... */ };

stack < cat > s; // ошибка: стек - абстрактный класс

void some_function ( stack <cat> & s, cat kitty ) // нормально

{