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

double sqrt ( double arg )

программа для вычисления квадратного корня void some function ()

double root = sqrt ( 2 );

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

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

1.2.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). Помимо этого С++, естественно, имеет уже продемонстрированные возможности модульности, которые есть в С, т.е. представление модуля как отдельной единицы трансляции.

1.2.3 Абстракция данных

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

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 );

присваиванием указателей, но здесь 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 ( al.re + a2.re, al.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;

char c1 = pop ( s1 );

destroy stack ( s2 ); неприятная ошибка

ошибка: забыли уничтожить s1 s1 = s2; это присваивание является по сути