Страница:
механизм контроля доступа, конструкторы и деструкторы, перегрузка
операций, преобразования пользовательских типов, обработка особых ситуаций
и шаблоны типов. Подробно эти возможности описаны в главах 5, 7, 8 и 9.
$$1.5 содержит описание средств поддержки объектно-ориентированного
программирования. В частности, определяются производные классы и
виртуальные функции, обсуждаются некоторые вопросы реализации. Все это
подробно изложено в главе 6.
$$1.6 содержит описание определенных ограничений на пути
совершенствования как языков программирования общего назначения вообще,
так и С++ в частности. Эти ограничения связаны с эффективностью, с
противоречащими друг другу требованиями разных областей приложения,
проблемами обучения и необходимостью трансляции и выполнения программ в
старых системах.
Если какой-то раздел окажется для вас непонятным, настоятельно
советуем прочитать соответствующие главы, а затем, ознакомившись с
подробным описанием основных конструкций языка, вернуться к этой главе.
Она нужна для того, чтобы можно было составить общее представление о
языке. В ней недостаточно сведений, чтобы немедленно начать
программировать.
Объектно-ориентированное программирование - это метод
программирования, способ написания "хороших" программ для множества задач.
Если этот термин имеет какой-то смысл, то он должен подразумевать: такой
язык программирования, который предоставляет хорошие возможности для
объектно-ориентированного стиля программирования.
Здесь следует указать на важные различия. Говорят, что язык
поддерживает некоторый стиль программирования, если в нем есть такие
возможности, которые делают программирование в этом стиле удобным
(достаточно простым, надежным и эффективным). Язык не поддерживает
некоторый стиль программирования, если требуются большие усилия или даже
искусство, чтобы написать программу в этом стиле. Однако это не означает,
что язык запрещает писать программы в этом стиле. Действительно, можно
писать структурные программы на Фортране и объектно-ориентированные
программы на С, но это будет пустой тратой сил, поскольку данные языки не
поддерживают указанных стилей программирования.
Поддержка языком определенной парадигмы (стиля) программирования явно
проявляется в конкретных языковых конструкциях, рассчитанных на нее. Но
она может проявляться в более тонкой, скрытой форме, когда отклонение от
парадигмы диагностируется на стадии трансляции или выполнения программы.
Самый очевидный пример - это контроль типов. Кроме того, языковая
поддержка парадигмы может дополняться проверкой на однозначность и
динамическим контролем. Поддержка может предоставляться и помимо самого
языка, например, стандартными библиотеками или средой программирования.
Нельзя сказать, что один язык лучше другого только потому, что в нем
есть возможности, которые в другом отсутствуют. Часто бывает как раз
наоборот. Здесь более важно не то, какими возможностями обладает язык, а
то, насколько имеющиеся в нем возможности поддерживают избранный стиль
программирования для определенного круга задач. Поэтому можно
сформулировать следующие требования к языку:
[1] Все конструкции языка должны естественно и элегантно определяться
в нем.
[2] Для решения определенной задачи должна быть возможность
использовать сочетания конструкций, чтобы избежать необходимости вводить
для этой цели новую конструкцию.
[3] Должно быть минимальное число неочевидных конструкций специального
назначения.
[4] Конструкция должна допускать такую реализацию, чтобы в
неиспользующей ее программе не возникло дополнительных расходов.
[5] Пользователю достаточно знать только то множество конструкций,
которое непосредственно используется в его программе.
Первое требование апеллирует к логике и эстетическому вкусу. Два
следующих выражают принцип минимальности. Два последних можно иначе
сформулировать так: "то, чего вы не знаете, не сможет нанести вам вреда".
С учетом ограничений, указанных в этих правилах, язык С++
проектировался для поддержки абстракции данных и объектно-ориентированного
программирования в добавление к традиционному стилю С. Впрочем, это не
значит, что язык требует какого-то одного стиля программирования от всех
пользователей.
Теперь перейдем к конкретным стилям программирования и посмотрим
каковы основные конструкции языка, их поддерживающие. Мы не собираемся
давать полное описание этих конструкций.
Первоначальной (и, возможно, наиболее используемой) парадигмой
программирования было:
Определите, какие процедуры вам нужны; используйте лучшие из известных
вам алгоритмов!
Ударение делалось на обработку данных с помощью алгоритма,
производящего нужные вычисления. Для поддержки этой парадигмы языки
предоставляли механизм передачи параметров и получения результатов
функций. Литература, отражающая такой подход, заполнена рассуждениями о
способах передачи параметров, о том, как различать параметры разных типов,
о различных видах функций (процедуры, подпрограммы, макрокоманды, ...) и
т.д. Первым процедурным языком был Фортран, а Алгол60, Алгол68, Паскаль и
С продолжили это направление.
Типичным примером хорошего стиля в таком понимании может служить
функция извлечения квадратного корня. Для заданного параметра она выдает
результат, который получается с помощью понятных математических операций:
double sqrt ( double arg )
{
// программа для вычисления квадратного корня
}
voide some_function ()
{
double root = sqrt ( 2 );
// ..
}
Двойная наклонная черта // начинает комментарий, который продолжается
до конца строки.
При такой организации программы функции вносят определенный порядок в
хаос различных алгоритмов.
Со временем при в проектировании программ акцент сместился с
организации процедур на организацию структур данных. Помимо всего прочего
это вызвано и ростом размеров программ. Модулем обычно называют
совокупность связанных процедур и тех данных, которыми они управляют.
Парадигма программирования приобрела вид:
Определите, какие модули нужны; поделите программу так, чтобы данные
были скрыты в этих модулях
Эта парадигма известна также как "принцип сокрытия данных". Если в
языке нет возможности сгруппировать связанные процедуры вместе с данными,
то он плохо поддерживает модульный стиль программирования. Теперь метод
написания "хороших" процедур применяется для отдельных процедур модуля.
Типичный пример модуля - определение стека. Здесь необходимо решить такие
задачи:
[1] Предоставить пользователю интерфейс для стека (например, функции
push () и pop ()).
[2] Гарантировать, что представление стека (например, в виде массива
элементов) будет доступно лишь через интерфейс пользователя.
[3] Обеспечивать инициализацию стека перед первым его использованием.
Язык Модула-2 прямо поддерживает эту парадигму, тогда как С только
допускает такой стиль. Ниже представлен на С возможный внешний интерфейс
модуля, реализующего стек:
// описание интерфейса для модуля,
// реализующего стек символов:
void push ( char );
char pop ();
const int stack_size = 100;
Допустим, что описание интерфейса находится в файле stack.h, тогда
реализацию стека можно определить следующим образом:
#include "stack.h" // используем интерфейс стека
static char v [ stack_size ]; // ``static'' означает локальный
// в данном файле/модуле
static char * p = v; // стек вначале пуст
void push ( char c )
{
//проверить на переполнение и поместить в стек
}
char pop ()
{
//проверить, не пуст ли стек, и считать из него
}
Вполне возможно, что реализация стека может измениться, например, если
использовать для хранения связанный список. Пользователь в любом случае не
имеет непосредственного доступа к реализации: v и p - статические
переменные, т.е. переменные локальные в том модуле (файле), в котором они
описаны. Использовать стек можно так:
#include "stack.h" // используем интерфейс стека
void some_function ()
{
push ( 'c' );
char c = pop ();
if ( c != 'c' ) error ( "невозможно" );
}
Поскольку данные есть единственная вещь, которую хотят скрывать,
понятие упрятывания данных тривиально расширяется до понятия упрятывания
информации, т.е. имен переменных, констант, функций и типов, которые тоже
могут быть локальными в модуле. Хотя С++ и не предназначался специально
для поддержки модульного программирования, классы поддерживают концепцию
модульности ($$5.4.3 и $$5.4.4). Помимо этого С++, естественно, имеет уже
продемонстрированные возможности модульности, которые есть в С, т.е.
представление модуля как отдельной единицы трансляции.
Модульное программирование предполагает группировку всех данных одного
типа вокруг одного модуля, управляющего этим типом. Если потребуются стеки
двух разных видов, можно определить управляющий ими модуль с таким
интерфейсом:
class stack_id { /* ... */ }; // stack_id только тип
// никакой информации о стеках
// здесь не содержится
stack_id create_stack ( int size ); // создать стек и возвратить
// его идентификатор
void push ( stack_id, char );
char pop ( stack_id );
destroy_stack ( stack_id ); // уничтожение стека
Конечно такое решение намного лучше, чем хаос, свойственный
традиционным, неструктурированным решениям, но моделируемые таким способом
типы совершенно очевидно отличаются от "настоящих", встроенных. Каждый
управляющий типом модуль должен определять свой собственный алгоритм
создания "переменных" этого типа. Не существует универсальных правил
присваивания идентификаторов, обозначающих объекты такого типа. У
"переменных" таких типов не существует имен, которые были бы известны
транслятору или другим системным программам, и эти "переменные" не
подчиняются обычным правилам областей видимости и передачи параметров.
Тип, реализуемый управляющим им модулем, по многим важным аспектам
существенно отличается от встроенных типов. Такие типы не получают той
поддержки со стороны транслятора (разного вида контроль), которая
обеспечивается для встроенных типов. Проблема здесь в том, что программа
формулируется в терминах небольших (одно-два слова) дескрипторов объектов,
а не в терминах самих объектов ( stack_id может служить примером такого
дескриптора). Это означает, что транслятор не сможет отловить глупые,
очевидные ошибки, вроде тех, что допущены в приведенной ниже функции:
void f ()
{
stack_id s1;
stack_id s2;
s1 = create_stack ( 200 );
// ошибка: забыли создать s2
push ( s1,'a' );
char c1 = pop ( s1 );
destroy_stack ( s2 ); // неприятная ошибка
// ошибка: забыли уничтожить s1
s1 = s2; // это присваивание является по сути
// присваиванием указателей,
// но здесь s2 используется после уничтожения
}
Иными словами, концепция модульности, поддерживающая парадигму
упрятывания данных, не запрещает такой стиль программирования, но и не
способствует ему.
В языках Ада, Clu, С++ и подобных им эта трудность преодолевается
благодаря тому, что пользователю разрешается определять свои типы, которые
трактуются в языке практически так же, как встроенные. Такие типы обычно
называют абстрактными типами данных, хотя лучше, пожалуй, их называть
просто пользовательскими. Более строгим определением абстрактных типов
данных было бы их математическое определение. Если бы удалось его дать,
то, что мы называем в программировании типами, было бы конкретным
представлением действительно абстрактных сущностей. Как определить "более
абстрактные" типы, показано в $$4.6. Парадигму же программирования можно
выразить теперь так:
Определите, какие типы вам нужны; предоставьте полный набор операций
для каждого типа.
Если нет необходимости в разных объектах одного типа, то стиль
программирования, суть которого сводится к упрятыванию данных, и
следование которому обеспечивается с помощью концепции модульности, вполне
адекватен этой парадигме.
Арифметические типы, подобные типам рациональных и комплексных чисел,
являются типичными примерами пользовательских типов:
class complex
{
double re, im;
public:
complex(double r, double i) { re=r; im=i; }
complex(double r) // преобразование float->complex
{ re=r; im=0; }
friend complex operator+(complex, complex);
friend complex operator-(complex, complex); // вычитание
friend complex operator-(complex) // унарный минус
friend complex operator*(complex, complex);
friend complex operator/(complex, complex);
// ...
};
Описание класса (т.е. определяемого пользователем типа) complex задает
представление комплексного числа и набор операций с комплексными числами.
Представление является частным (private): re и im доступны только для
функций, указанных в описании класса complex. Подобные функции могут быть
определены так:
complex operator + ( complex a1, complex a2 )
{
return complex ( a1.re + a2.re, a1.im + a2.im );
}
и использоваться следующим образом:
void f ()
{
complex a = 2.3;
complex b = 1 / a;
complex c = a + b * complex ( 1, 2.3 );
// ...
c = - ( a / b ) + 2;
}
Большинство модулей (хотя и не все) лучше определять как
пользовательские типы.
Абстрактный тип данных определяется как некий "черный ящик". После
своего определения он по сути никак не взаимодействует с программой. Его
никак нельзя приспособить для новых целей, не меняя определения. В этом
смысле это негибкое решение. Пусть, например, нужно определить для
графической системы тип shape (фигура). Пока считаем, что в системе могут
быть такие фигуры: окружность (circle), треугольник (triangle) и квадрат
(square). Пусть уже есть определения точки и цвета:
class point { /* ... */ };
class color { /* ... */ };
Тип shape можно определить следующим образом:
enum kind { circle, triangle, square };
class shape
{
point center;
color col;
kind k;
// представление фигуры
public:
point where () { return center; }
void move ( point to ) { center = to; draw (); }
void draw ();
void rotate ( int );
// еще некоторые операции
};
"Поле типа" k необходимо для того, чтобы такие операции, как draw () и
rotate (), могли определять, с какой фигурой они имеют дело (в языках
вроде Паскаля можно использовать для этого запись с вариантами, в которой
k является полем-дескриминантом). Функцию draw () можно определить так:
void shape :: draw ()
{
switch ( k )
{
case circle:
// рисование окружности
break;
case triangle:
// рисование треугольника
break;
case square:
// рисование квадрата
break;
}
}
Это не функция, а кошмар. В ней нужно учесть все возможные фигуры,
какие только есть. Поэтому она дополняется новыми операторами, как только
в системе появляется новая фигура. Плохо то, что после определения новой
фигуры нужно проверить и, возможно, изменить все старые операции класса.
Поэтому, если вам недоступен исходный текст каждой операции класса, ввести
новую фигуру в систему просто невозможно. Появление любой новой фигуры
приводит к манипуляциям с текстом каждой существенной операции класса.
Требуется достаточно высокая квалификация, чтобы справиться с этой
задачей, но все равно могут появиться ошибки в уже отлаженных частях
программы, работающих со старыми фигурами. Возможность выбора
представления для конкретной фигуры сильно сужается, если требовать, чтобы
все ее представления укладывались в уже заданный формат, специфицированный
общим определением фигуры (т.е. определением типа shape).
Проблема состоит в том, что мы не различаем общие свойства фигур
(например, фигура имеет цвет, ее можно нарисовать и т.д.) и свойства
конкретной фигуры (например, окружность - это такая фигура, которая имеет
радиус, она изображается с помощью функции, рисующей дуги и т.д.). Суть
объектно-ориентированного программирования в том, что оно позволяет
выражать эти различия и использует их. Язык, который имеет конструкции для
выражения и использования подобных различий, поддерживает
объектно-ориентированное программирование. Все другие языки не
поддерживают его. Здесь основную роль играет механизм наследования,
заимствованный из языка Симула. Вначале определим класс, задающий общие
свойства всех фигур:
class shape
{
point center;
color col;
// ...
public:
point where () { return center; }
void move ( point to ) { center = to; draw(); }
virtual void draw ();
virtual void rotate ( int );
// ...
};
Те функции, для которых можно определить заявленный интерфейс, но
реализация которых (т.е. тело с операторной частью) возможна только для
конкретных фигур, отмечены служебным словом virtual (виртуальные). В
Симуле и С++ виртуальность функции означает: "функция может быть
определена позднее в классе, производном от данного". С учетом такого
определения класса можно написать общие функции, работающие с фигурами:
void rotate_all ( shape v [], int size, int angle )
// повернуть все элементы массива "v" размера "size"
// на угол равный "angle"
{
int i = 0;
while ( i<size )
{
v [ i ] . rotate ( angle );
i = i + 1;
}
}
Для определения конкретной фигуры следует указать, прежде всего, что
это - именно фигура и задать ее особые свойства (включая и виртуальные
функции):
class circle : public shape
{
int radius;
public:
void draw () { /* ... */ };
void rotate ( int ) {} // да, пока пустая функция
};
В языке С++ класс circle называется производным по отношению к классу
shape, а класс shape называется базовым для класса circle. Возможна
другая терминология, использующая названия "подкласс" и "суперкласс" для
классов circle и shape соответственно. Теперь парадигма программирования
формулируется так:
Определите, какой класс вам необходим; предоставьте полный набор
операций для каждого класса; общность классов выразите явно с помощью
наследования.
Если общность между классами отсутствует, вполне достаточно абстракции
данных. Насколько применимо объектно-ориентированное программирование для
данной области приложения определяется степенью общности между разными
типами, которая позволяет использовать наследование и виртуальные функции.
В некоторых областях, таких, например, как интерактивная графика, есть
широкий простор для объектно-ориентированного программирования. В других
областях, в которых используются традиционные арифметические типы и
вычисления над ними, трудно найти применение для более развитых стилей
программирования, чем абстракция данных. Здесь средства, поддерживающие
объектно-ориентированное программирование, очевидно, избыточны.
Нахождение общности среди отдельных типов системы представляет собой
нетривиальный процесс. Степень такой общности зависит от способа
проектирования системы. В процессе проектирования выявление общности
классов должно быть постоянной целью. Она достигается двумя способами:
либо проектированием специальных классов, используемых как "кирпичи" при
построении других, либо поиском похожих классов для выделения их общей
части в один базовый класс.
С попытками объяснить, что такое объектно-ориентированное
программирование, не используя конкретных конструкций языков
программирования, можно познакомиться в работах [2] и [6], приведенных в
списке литературы в главе 11.
Итак, мы указали, какую минимальную поддержку должен обеспечивать язык
программирования для процедурного программирования, для упрятывания
данных, абстракции данных и объектно-ориентированного программирования.
Теперь несколько подробнее опишем средства языка, хотя и не самые
существенные, но позволяющие более эффективно реализовать абстракцию
данных и объектно-ориентированное программирование.
Минимальная поддержка процедурного программирования включает функции,
арифметические операции, выбирающие операторы и циклы. Помимо этого должны
быть предоставлены операции ввода- вывода. Базовые языковые средства С++
унаследовал от С (включая указатели), а операции ввода-вывода
предоставляются библиотекой. Самая зачаточная концепция модульности
реализуется с помощью механизма раздельной трансляции.
Самая маленькая программа на С++ выглядит так:
main () { }
В этой программе определяется функция, называемая main, которая не
имеет параметров и ничего не делает. Фигурные скобки { и } используются в
С++ для группирования операторов. В данном случае они обозначают начало и
конец тела (пустого) функции main. В каждой программе на С++ должна быть
своя функция main(), и программа начинается с выполнения этой функции.
Обычно программа выдает какие-то результаты. Вот программа, которая
выдает приветствие Hello, World! (Всем привет!):
#include <iostream.h>
int main ()
{
cout << "Hello, World!\n";
}
Строка #include <iostream.h> сообщает транслятору, что надо включить в
программу описания, необходимые для работы стандартных потоков ввода-
вывода, которые находятся в iostream.h. Без этих описаний выражение
cout << "Hello, World!\n"
не имело бы смысла. Операция << ("выдать") записывает свой второй
параметр в первый параметр. В данном случае строка "Hello, World!\n"
записывается в стандартный выходной поток cout. Строка - это
последовательность символов, заключенная в двойные кавычки. Два символа:
обратной дробной черты \ и непосредственно следующий за ним - обозначают
некоторый специальный символ. В данном случае \n является символом конца
строки (или перевода строки), поэтому он выдается после символов Hello,
world!
Целое значение, возвращаемое функцией main(), если только оно есть,
считается возвращаемым системе значением программы. Если ничего не
возвращается, система получит какое-то "мусорное" значение.
Средства ввода/вывода потоковой библиотеки подробно описываются в
главе 10.
Каждое имя и каждое выражение обязаны иметь тип. Именно тип определяет
операции, которые могут выполняться над ними. Например, в описании
int inch;
говорится, что inch имеет тип int, т.е. inch является целой
переменной.
Описание - это оператор, который вводит имя в программу. В описании
указывается тип имени. Тип, в свою очередь, определяет как правильно
использовать имя или выражение.
Основные типы, наиболее приближенные к "аппаратной реальности" машины,
таковы:
char
short
int
long
Они представляют целые числа. Следующие типы:
float
double
long double
представляют числа с плавающей точкой. Переменная типа char имеет
размер, нужный для хранения одного символа на данной машине (обычно это
один байт). Переменная int имеет размер, необходимый для целой арифметики
на данной машине (обычно это одно слово).
Следующие арифметические операции можно использовать над любым
сочетанием перечисленных типов:
+ (плюс, унарный и бинарный)
- (минус, унарный и бинарный)
* (умножение)
/ (деление)
% (остаток от деления)
То же верно для операций отношения:
== (равно)
!= (не равно)
< (меньше чем)
<= (меньше или равно)
>= (больше или равно)
Для операций присваивания и арифметических операций в С++ выполняются
все осмысленные преобразования основных типов, чтобы их можно было
неограниченно использовать любые их сочетания:
double d;
int i;
short s;
// ...
d = d + i;
i = s * i;
Символ = обозначает обычное присваивание.
Массив можно описать так:
char v [ 10 ]; // массив из 10 символов
Описание указателя имеет такой вид:
char * p; // указатель на символ
Здесь [] означает "массив из", а символ * означает "указатель на".
Значение нижней границы индекса для всех массивов равно нулю, поэтому v
имеет 10 элементов: v [ 0 ] ... v [ 9 ]. Переменная типа указатель может
содержать адрес объекта соответствующего типа:
p = & v [ 3 ]; // p указывает на 4-й элемент массива v
Унарная операция & означает взятие адреса.
В С++ есть традиционный набор выбирающих операторов и циклов. Ниже
приводятся примеры операторов if, switch и while.
В следующем примере показано преобразование дюйма в сантиметр и
обратно. Предполагается, что во входном потоке значение в сантиметрах
завершается символом i, а значение в дюймах - символом c:
#include <iostream.h>
int main ()
{
const float fac = 2.54;
float x, in, cm;
char ch = 0;
cout << "enter length: ";
cin >> x; // ввод числа с плавающей точкой
cin >> ch // ввод завершающего символа
if ( ch == 'i' )
{ // дюйм
in = x;
cm = x * fac;
}
else if ( ch == 'c' )
{ // сантиметры
in = x / fac;
cm = x;
}
else
in = cm = 0;
cout << in << " in = " << cm << " cm\n";
}
Операция >> ("ввести из") используется как оператор ввода; cin
является стандартным входным потоком. Тип операнда, расположенного справа
от операции >>, определяет, какое значение вводится; оно записывается в
этот операнд.
Оператор switch (переключатель) сравнивает значение с набором
констант. Проверку в предыдущем примере можно записать так:
switch ( ch )
{
case 'i':
in = x;
cm = x * fac;
break;
case 'c':
in = x / fac;
cm = x;
break;
default:
in = cm = 0;
break;
}
Операторы break используются для выхода из переключателя. Все
константы вариантов должны быть различны. Если сравниваемое значение не
совпадает ни с одной из них, выполняется оператор с меткой default.
Вариант default может и отсутствовать.
Приведем запись, задающую копирование 10 элементов одного массива в
другой:
int v1 [ 10 ];
int v2 [ 10 ];
// ...
for ( int i=0; i<10; i++ ) v1 [ i ] = v2 [ i ];
Словами это можно выразить так: "Начать с i равного нулю, и пока i
операций, преобразования пользовательских типов, обработка особых ситуаций
и шаблоны типов. Подробно эти возможности описаны в главах 5, 7, 8 и 9.
$$1.5 содержит описание средств поддержки объектно-ориентированного
программирования. В частности, определяются производные классы и
виртуальные функции, обсуждаются некоторые вопросы реализации. Все это
подробно изложено в главе 6.
$$1.6 содержит описание определенных ограничений на пути
совершенствования как языков программирования общего назначения вообще,
так и С++ в частности. Эти ограничения связаны с эффективностью, с
противоречащими друг другу требованиями разных областей приложения,
проблемами обучения и необходимостью трансляции и выполнения программ в
старых системах.
Если какой-то раздел окажется для вас непонятным, настоятельно
советуем прочитать соответствующие главы, а затем, ознакомившись с
подробным описанием основных конструкций языка, вернуться к этой главе.
Она нужна для того, чтобы можно было составить общее представление о
языке. В ней недостаточно сведений, чтобы немедленно начать
программировать.
Объектно-ориентированное программирование - это метод
программирования, способ написания "хороших" программ для множества задач.
Если этот термин имеет какой-то смысл, то он должен подразумевать: такой
язык программирования, который предоставляет хорошие возможности для
объектно-ориентированного стиля программирования.
Здесь следует указать на важные различия. Говорят, что язык
поддерживает некоторый стиль программирования, если в нем есть такие
возможности, которые делают программирование в этом стиле удобным
(достаточно простым, надежным и эффективным). Язык не поддерживает
некоторый стиль программирования, если требуются большие усилия или даже
искусство, чтобы написать программу в этом стиле. Однако это не означает,
что язык запрещает писать программы в этом стиле. Действительно, можно
писать структурные программы на Фортране и объектно-ориентированные
программы на С, но это будет пустой тратой сил, поскольку данные языки не
поддерживают указанных стилей программирования.
Поддержка языком определенной парадигмы (стиля) программирования явно
проявляется в конкретных языковых конструкциях, рассчитанных на нее. Но
она может проявляться в более тонкой, скрытой форме, когда отклонение от
парадигмы диагностируется на стадии трансляции или выполнения программы.
Самый очевидный пример - это контроль типов. Кроме того, языковая
поддержка парадигмы может дополняться проверкой на однозначность и
динамическим контролем. Поддержка может предоставляться и помимо самого
языка, например, стандартными библиотеками или средой программирования.
Нельзя сказать, что один язык лучше другого только потому, что в нем
есть возможности, которые в другом отсутствуют. Часто бывает как раз
наоборот. Здесь более важно не то, какими возможностями обладает язык, а
то, насколько имеющиеся в нем возможности поддерживают избранный стиль
программирования для определенного круга задач. Поэтому можно
сформулировать следующие требования к языку:
[1] Все конструкции языка должны естественно и элегантно определяться
в нем.
[2] Для решения определенной задачи должна быть возможность
использовать сочетания конструкций, чтобы избежать необходимости вводить
для этой цели новую конструкцию.
[3] Должно быть минимальное число неочевидных конструкций специального
назначения.
[4] Конструкция должна допускать такую реализацию, чтобы в
неиспользующей ее программе не возникло дополнительных расходов.
[5] Пользователю достаточно знать только то множество конструкций,
которое непосредственно используется в его программе.
Первое требование апеллирует к логике и эстетическому вкусу. Два
следующих выражают принцип минимальности. Два последних можно иначе
сформулировать так: "то, чего вы не знаете, не сможет нанести вам вреда".
С учетом ограничений, указанных в этих правилах, язык С++
проектировался для поддержки абстракции данных и объектно-ориентированного
программирования в добавление к традиционному стилю С. Впрочем, это не
значит, что язык требует какого-то одного стиля программирования от всех
пользователей.
Теперь перейдем к конкретным стилям программирования и посмотрим
каковы основные конструкции языка, их поддерживающие. Мы не собираемся
давать полное описание этих конструкций.
Первоначальной (и, возможно, наиболее используемой) парадигмой
программирования было:
Определите, какие процедуры вам нужны; используйте лучшие из известных
вам алгоритмов!
Ударение делалось на обработку данных с помощью алгоритма,
производящего нужные вычисления. Для поддержки этой парадигмы языки
предоставляли механизм передачи параметров и получения результатов
функций. Литература, отражающая такой подход, заполнена рассуждениями о
способах передачи параметров, о том, как различать параметры разных типов,
о различных видах функций (процедуры, подпрограммы, макрокоманды, ...) и
т.д. Первым процедурным языком был Фортран, а Алгол60, Алгол68, Паскаль и
С продолжили это направление.
Типичным примером хорошего стиля в таком понимании может служить
функция извлечения квадратного корня. Для заданного параметра она выдает
результат, который получается с помощью понятных математических операций:
double sqrt ( double arg )
{
// программа для вычисления квадратного корня
}
voide some_function ()
{
double root = sqrt ( 2 );
// ..
}
Двойная наклонная черта // начинает комментарий, который продолжается
до конца строки.
При такой организации программы функции вносят определенный порядок в
хаос различных алгоритмов.
Со временем при в проектировании программ акцент сместился с
организации процедур на организацию структур данных. Помимо всего прочего
это вызвано и ростом размеров программ. Модулем обычно называют
совокупность связанных процедур и тех данных, которыми они управляют.
Парадигма программирования приобрела вид:
Определите, какие модули нужны; поделите программу так, чтобы данные
были скрыты в этих модулях
Эта парадигма известна также как "принцип сокрытия данных". Если в
языке нет возможности сгруппировать связанные процедуры вместе с данными,
то он плохо поддерживает модульный стиль программирования. Теперь метод
написания "хороших" процедур применяется для отдельных процедур модуля.
Типичный пример модуля - определение стека. Здесь необходимо решить такие
задачи:
[1] Предоставить пользователю интерфейс для стека (например, функции
push () и pop ()).
[2] Гарантировать, что представление стека (например, в виде массива
элементов) будет доступно лишь через интерфейс пользователя.
[3] Обеспечивать инициализацию стека перед первым его использованием.
Язык Модула-2 прямо поддерживает эту парадигму, тогда как С только
допускает такой стиль. Ниже представлен на С возможный внешний интерфейс
модуля, реализующего стек:
// описание интерфейса для модуля,
// реализующего стек символов:
void push ( char );
char pop ();
const int stack_size = 100;
Допустим, что описание интерфейса находится в файле stack.h, тогда
реализацию стека можно определить следующим образом:
#include "stack.h" // используем интерфейс стека
static char v [ stack_size ]; // ``static'' означает локальный
// в данном файле/модуле
static char * p = v; // стек вначале пуст
void push ( char c )
{
//проверить на переполнение и поместить в стек
}
char pop ()
{
//проверить, не пуст ли стек, и считать из него
}
Вполне возможно, что реализация стека может измениться, например, если
использовать для хранения связанный список. Пользователь в любом случае не
имеет непосредственного доступа к реализации: v и p - статические
переменные, т.е. переменные локальные в том модуле (файле), в котором они
описаны. Использовать стек можно так:
#include "stack.h" // используем интерфейс стека
void some_function ()
{
push ( 'c' );
char c = pop ();
if ( c != 'c' ) error ( "невозможно" );
}
Поскольку данные есть единственная вещь, которую хотят скрывать,
понятие упрятывания данных тривиально расширяется до понятия упрятывания
информации, т.е. имен переменных, констант, функций и типов, которые тоже
могут быть локальными в модуле. Хотя С++ и не предназначался специально
для поддержки модульного программирования, классы поддерживают концепцию
модульности ($$5.4.3 и $$5.4.4). Помимо этого С++, естественно, имеет уже
продемонстрированные возможности модульности, которые есть в С, т.е.
представление модуля как отдельной единицы трансляции.
Модульное программирование предполагает группировку всех данных одного
типа вокруг одного модуля, управляющего этим типом. Если потребуются стеки
двух разных видов, можно определить управляющий ими модуль с таким
интерфейсом:
class stack_id { /* ... */ }; // stack_id только тип
// никакой информации о стеках
// здесь не содержится
stack_id create_stack ( int size ); // создать стек и возвратить
// его идентификатор
void push ( stack_id, char );
char pop ( stack_id );
destroy_stack ( stack_id ); // уничтожение стека
Конечно такое решение намного лучше, чем хаос, свойственный
традиционным, неструктурированным решениям, но моделируемые таким способом
типы совершенно очевидно отличаются от "настоящих", встроенных. Каждый
управляющий типом модуль должен определять свой собственный алгоритм
создания "переменных" этого типа. Не существует универсальных правил
присваивания идентификаторов, обозначающих объекты такого типа. У
"переменных" таких типов не существует имен, которые были бы известны
транслятору или другим системным программам, и эти "переменные" не
подчиняются обычным правилам областей видимости и передачи параметров.
Тип, реализуемый управляющим им модулем, по многим важным аспектам
существенно отличается от встроенных типов. Такие типы не получают той
поддержки со стороны транслятора (разного вида контроль), которая
обеспечивается для встроенных типов. Проблема здесь в том, что программа
формулируется в терминах небольших (одно-два слова) дескрипторов объектов,
а не в терминах самих объектов ( stack_id может служить примером такого
дескриптора). Это означает, что транслятор не сможет отловить глупые,
очевидные ошибки, вроде тех, что допущены в приведенной ниже функции:
void f ()
{
stack_id s1;
stack_id s2;
s1 = create_stack ( 200 );
// ошибка: забыли создать s2
push ( s1,'a' );
char c1 = pop ( s1 );
destroy_stack ( s2 ); // неприятная ошибка
// ошибка: забыли уничтожить s1
s1 = s2; // это присваивание является по сути
// присваиванием указателей,
// но здесь s2 используется после уничтожения
}
Иными словами, концепция модульности, поддерживающая парадигму
упрятывания данных, не запрещает такой стиль программирования, но и не
способствует ему.
В языках Ада, Clu, С++ и подобных им эта трудность преодолевается
благодаря тому, что пользователю разрешается определять свои типы, которые
трактуются в языке практически так же, как встроенные. Такие типы обычно
называют абстрактными типами данных, хотя лучше, пожалуй, их называть
просто пользовательскими. Более строгим определением абстрактных типов
данных было бы их математическое определение. Если бы удалось его дать,
то, что мы называем в программировании типами, было бы конкретным
представлением действительно абстрактных сущностей. Как определить "более
абстрактные" типы, показано в $$4.6. Парадигму же программирования можно
выразить теперь так:
Определите, какие типы вам нужны; предоставьте полный набор операций
для каждого типа.
Если нет необходимости в разных объектах одного типа, то стиль
программирования, суть которого сводится к упрятыванию данных, и
следование которому обеспечивается с помощью концепции модульности, вполне
адекватен этой парадигме.
Арифметические типы, подобные типам рациональных и комплексных чисел,
являются типичными примерами пользовательских типов:
class complex
{
double re, im;
public:
complex(double r, double i) { re=r; im=i; }
complex(double r) // преобразование float->complex
{ re=r; im=0; }
friend complex operator+(complex, complex);
friend complex operator-(complex, complex); // вычитание
friend complex operator-(complex) // унарный минус
friend complex operator*(complex, complex);
friend complex operator/(complex, complex);
// ...
};
Описание класса (т.е. определяемого пользователем типа) complex задает
представление комплексного числа и набор операций с комплексными числами.
Представление является частным (private): re и im доступны только для
функций, указанных в описании класса complex. Подобные функции могут быть
определены так:
complex operator + ( complex a1, complex a2 )
{
return complex ( a1.re + a2.re, a1.im + a2.im );
}
и использоваться следующим образом:
void f ()
{
complex a = 2.3;
complex b = 1 / a;
complex c = a + b * complex ( 1, 2.3 );
// ...
c = - ( a / b ) + 2;
}
Большинство модулей (хотя и не все) лучше определять как
пользовательские типы.
Абстрактный тип данных определяется как некий "черный ящик". После
своего определения он по сути никак не взаимодействует с программой. Его
никак нельзя приспособить для новых целей, не меняя определения. В этом
смысле это негибкое решение. Пусть, например, нужно определить для
графической системы тип shape (фигура). Пока считаем, что в системе могут
быть такие фигуры: окружность (circle), треугольник (triangle) и квадрат
(square). Пусть уже есть определения точки и цвета:
class point { /* ... */ };
class color { /* ... */ };
Тип shape можно определить следующим образом:
enum kind { circle, triangle, square };
class shape
{
point center;
color col;
kind k;
// представление фигуры
public:
point where () { return center; }
void move ( point to ) { center = to; draw (); }
void draw ();
void rotate ( int );
// еще некоторые операции
};
"Поле типа" k необходимо для того, чтобы такие операции, как draw () и
rotate (), могли определять, с какой фигурой они имеют дело (в языках
вроде Паскаля можно использовать для этого запись с вариантами, в которой
k является полем-дескриминантом). Функцию draw () можно определить так:
void shape :: draw ()
{
switch ( k )
{
case circle:
// рисование окружности
break;
case triangle:
// рисование треугольника
break;
case square:
// рисование квадрата
break;
}
}
Это не функция, а кошмар. В ней нужно учесть все возможные фигуры,
какие только есть. Поэтому она дополняется новыми операторами, как только
в системе появляется новая фигура. Плохо то, что после определения новой
фигуры нужно проверить и, возможно, изменить все старые операции класса.
Поэтому, если вам недоступен исходный текст каждой операции класса, ввести
новую фигуру в систему просто невозможно. Появление любой новой фигуры
приводит к манипуляциям с текстом каждой существенной операции класса.
Требуется достаточно высокая квалификация, чтобы справиться с этой
задачей, но все равно могут появиться ошибки в уже отлаженных частях
программы, работающих со старыми фигурами. Возможность выбора
представления для конкретной фигуры сильно сужается, если требовать, чтобы
все ее представления укладывались в уже заданный формат, специфицированный
общим определением фигуры (т.е. определением типа shape).
Проблема состоит в том, что мы не различаем общие свойства фигур
(например, фигура имеет цвет, ее можно нарисовать и т.д.) и свойства
конкретной фигуры (например, окружность - это такая фигура, которая имеет
радиус, она изображается с помощью функции, рисующей дуги и т.д.). Суть
объектно-ориентированного программирования в том, что оно позволяет
выражать эти различия и использует их. Язык, который имеет конструкции для
выражения и использования подобных различий, поддерживает
объектно-ориентированное программирование. Все другие языки не
поддерживают его. Здесь основную роль играет механизм наследования,
заимствованный из языка Симула. Вначале определим класс, задающий общие
свойства всех фигур:
class shape
{
point center;
color col;
// ...
public:
point where () { return center; }
void move ( point to ) { center = to; draw(); }
virtual void draw ();
virtual void rotate ( int );
// ...
};
Те функции, для которых можно определить заявленный интерфейс, но
реализация которых (т.е. тело с операторной частью) возможна только для
конкретных фигур, отмечены служебным словом virtual (виртуальные). В
Симуле и С++ виртуальность функции означает: "функция может быть
определена позднее в классе, производном от данного". С учетом такого
определения класса можно написать общие функции, работающие с фигурами:
void rotate_all ( shape v [], int size, int angle )
// повернуть все элементы массива "v" размера "size"
// на угол равный "angle"
{
int i = 0;
while ( i<size )
{
v [ i ] . rotate ( angle );
i = i + 1;
}
}
Для определения конкретной фигуры следует указать, прежде всего, что
это - именно фигура и задать ее особые свойства (включая и виртуальные
функции):
class circle : public shape
{
int radius;
public:
void draw () { /* ... */ };
void rotate ( int ) {} // да, пока пустая функция
};
В языке С++ класс circle называется производным по отношению к классу
shape, а класс shape называется базовым для класса circle. Возможна
другая терминология, использующая названия "подкласс" и "суперкласс" для
классов circle и shape соответственно. Теперь парадигма программирования
формулируется так:
Определите, какой класс вам необходим; предоставьте полный набор
операций для каждого класса; общность классов выразите явно с помощью
наследования.
Если общность между классами отсутствует, вполне достаточно абстракции
данных. Насколько применимо объектно-ориентированное программирование для
данной области приложения определяется степенью общности между разными
типами, которая позволяет использовать наследование и виртуальные функции.
В некоторых областях, таких, например, как интерактивная графика, есть
широкий простор для объектно-ориентированного программирования. В других
областях, в которых используются традиционные арифметические типы и
вычисления над ними, трудно найти применение для более развитых стилей
программирования, чем абстракция данных. Здесь средства, поддерживающие
объектно-ориентированное программирование, очевидно, избыточны.
Нахождение общности среди отдельных типов системы представляет собой
нетривиальный процесс. Степень такой общности зависит от способа
проектирования системы. В процессе проектирования выявление общности
классов должно быть постоянной целью. Она достигается двумя способами:
либо проектированием специальных классов, используемых как "кирпичи" при
построении других, либо поиском похожих классов для выделения их общей
части в один базовый класс.
С попытками объяснить, что такое объектно-ориентированное
программирование, не используя конкретных конструкций языков
программирования, можно познакомиться в работах [2] и [6], приведенных в
списке литературы в главе 11.
Итак, мы указали, какую минимальную поддержку должен обеспечивать язык
программирования для процедурного программирования, для упрятывания
данных, абстракции данных и объектно-ориентированного программирования.
Теперь несколько подробнее опишем средства языка, хотя и не самые
существенные, но позволяющие более эффективно реализовать абстракцию
данных и объектно-ориентированное программирование.
Минимальная поддержка процедурного программирования включает функции,
арифметические операции, выбирающие операторы и циклы. Помимо этого должны
быть предоставлены операции ввода- вывода. Базовые языковые средства С++
унаследовал от С (включая указатели), а операции ввода-вывода
предоставляются библиотекой. Самая зачаточная концепция модульности
реализуется с помощью механизма раздельной трансляции.
Самая маленькая программа на С++ выглядит так:
main () { }
В этой программе определяется функция, называемая main, которая не
имеет параметров и ничего не делает. Фигурные скобки { и } используются в
С++ для группирования операторов. В данном случае они обозначают начало и
конец тела (пустого) функции main. В каждой программе на С++ должна быть
своя функция main(), и программа начинается с выполнения этой функции.
Обычно программа выдает какие-то результаты. Вот программа, которая
выдает приветствие Hello, World! (Всем привет!):
#include <iostream.h>
int main ()
{
cout << "Hello, World!\n";
}
Строка #include <iostream.h> сообщает транслятору, что надо включить в
программу описания, необходимые для работы стандартных потоков ввода-
вывода, которые находятся в iostream.h. Без этих описаний выражение
cout << "Hello, World!\n"
не имело бы смысла. Операция << ("выдать") записывает свой второй
параметр в первый параметр. В данном случае строка "Hello, World!\n"
записывается в стандартный выходной поток cout. Строка - это
последовательность символов, заключенная в двойные кавычки. Два символа:
обратной дробной черты \ и непосредственно следующий за ним - обозначают
некоторый специальный символ. В данном случае \n является символом конца
строки (или перевода строки), поэтому он выдается после символов Hello,
world!
Целое значение, возвращаемое функцией main(), если только оно есть,
считается возвращаемым системе значением программы. Если ничего не
возвращается, система получит какое-то "мусорное" значение.
Средства ввода/вывода потоковой библиотеки подробно описываются в
главе 10.
Каждое имя и каждое выражение обязаны иметь тип. Именно тип определяет
операции, которые могут выполняться над ними. Например, в описании
int inch;
говорится, что inch имеет тип int, т.е. inch является целой
переменной.
Описание - это оператор, который вводит имя в программу. В описании
указывается тип имени. Тип, в свою очередь, определяет как правильно
использовать имя или выражение.
Основные типы, наиболее приближенные к "аппаратной реальности" машины,
таковы:
char
short
int
long
Они представляют целые числа. Следующие типы:
float
double
long double
представляют числа с плавающей точкой. Переменная типа char имеет
размер, нужный для хранения одного символа на данной машине (обычно это
один байт). Переменная int имеет размер, необходимый для целой арифметики
на данной машине (обычно это одно слово).
Следующие арифметические операции можно использовать над любым
сочетанием перечисленных типов:
+ (плюс, унарный и бинарный)
- (минус, унарный и бинарный)
* (умножение)
/ (деление)
% (остаток от деления)
То же верно для операций отношения:
== (равно)
!= (не равно)
< (меньше чем)
<= (меньше или равно)
>= (больше или равно)
Для операций присваивания и арифметических операций в С++ выполняются
все осмысленные преобразования основных типов, чтобы их можно было
неограниченно использовать любые их сочетания:
double d;
int i;
short s;
// ...
d = d + i;
i = s * i;
Символ = обозначает обычное присваивание.
Массив можно описать так:
char v [ 10 ]; // массив из 10 символов
Описание указателя имеет такой вид:
char * p; // указатель на символ
Здесь [] означает "массив из", а символ * означает "указатель на".
Значение нижней границы индекса для всех массивов равно нулю, поэтому v
имеет 10 элементов: v [ 0 ] ... v [ 9 ]. Переменная типа указатель может
содержать адрес объекта соответствующего типа:
p = & v [ 3 ]; // p указывает на 4-й элемент массива v
Унарная операция & означает взятие адреса.
В С++ есть традиционный набор выбирающих операторов и циклов. Ниже
приводятся примеры операторов if, switch и while.
В следующем примере показано преобразование дюйма в сантиметр и
обратно. Предполагается, что во входном потоке значение в сантиметрах
завершается символом i, а значение в дюймах - символом c:
#include <iostream.h>
int main ()
{
const float fac = 2.54;
float x, in, cm;
char ch = 0;
cout << "enter length: ";
cin >> x; // ввод числа с плавающей точкой
cin >> ch // ввод завершающего символа
if ( ch == 'i' )
{ // дюйм
in = x;
cm = x * fac;
}
else if ( ch == 'c' )
{ // сантиметры
in = x / fac;
cm = x;
}
else
in = cm = 0;
cout << in << " in = " << cm << " cm\n";
}
Операция >> ("ввести из") используется как оператор ввода; cin
является стандартным входным потоком. Тип операнда, расположенного справа
от операции >>, определяет, какое значение вводится; оно записывается в
этот операнд.
Оператор switch (переключатель) сравнивает значение с набором
констант. Проверку в предыдущем примере можно записать так:
switch ( ch )
{
case 'i':
in = x;
cm = x * fac;
break;
case 'c':
in = x / fac;
cm = x;
break;
default:
in = cm = 0;
break;
}
Операторы break используются для выхода из переключателя. Все
константы вариантов должны быть различны. Если сравниваемое значение не
совпадает ни с одной из них, выполняется оператор с меткой default.
Вариант default может и отсутствовать.
Приведем запись, задающую копирование 10 элементов одного массива в
другой:
int v1 [ 10 ];
int v2 [ 10 ];
// ...
for ( int i=0; i<10; i++ ) v1 [ i ] = v2 [ i ];
Словами это можно выразить так: "Начать с i равного нулю, и пока i