ЧТО ТАКОЕ ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ

Биарне Строустрап

Не все языки программирования могут быть объектно-ориентированными.Да, были сделаны утверждения, что APL, Ada, Clu, C++, Loops и Swalltalk объектно-ориентированные языки. Мне приходилось слышать дискуссии об объектно-ориентированном программировании на C, Pascal, Modula-2 и Chill. Могут ли говорить об объектно-ориентированном программировании на языках Fortran и Cobol? Я думаю, что где-нибудь этоделают.

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

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

ПОДХОДЫ В ПРОГРАММИРОВАНИИ

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

Здесь имеется важное различие: язык поддерживает стиль программирования, если располагает средствами сделать удобным его использование (действительно простым и эффективным). Язык не поддерживает некоторую технологию программирования, если для ее использования приходится затрачивать дополнительные усилия; в этом случае язык только обладает средствами для следования технологии. Например, можно писать структурированные программы на языке Fortran или строго типизированные - на С, или использовать абстрактные типы данных - в Modula -2, но это бессмысленно сложно делать, потому что эти языки не поддерживают упомянутые возможности.

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

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

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

ПРОЦЕДУРНОСТЬ. Изначальной и, вероятно, все еще самой общей парадигмой программирования является следующая: "Решите, какие процедуры вы желаете; используйте лучше из алгоритмов, которые можете найти".

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

Fortran является первым процедурным языком; Algol - 60, Algol-68, С, Pascal - более поздние проекты, продолжающие эту традицию.

В качестве примера хорошего процедурного стиля можно привести функцию извлечения квадратного корня. Функция точно получает результат для данного аргумента. Для этого она выполняет хорошо понятные математические вычисления.

     double sqrt (double arg)
     {
        //команды для вычисления корня
     }
     void some_function ()
     {
        double root2=sgrt(2);
        //...
  

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

ЛОКАЛИЗАЦИЯ ДАННЫХ.С течение лет, при разработке программ, внимание все более и более начало перемещаться с проектирования процедур к организации данных. Среди других причин этого, следует указать увеличение размеров программ. Множество связанных процедур и обрабатываемых данных часто называют модулем. Парадигма программирования здесь следующая: "Решите, какие модули вы желаете; разбейте программу таким образом, чтобы данные были спрятаны в модулях". Когда нет необходимости группировать процедуры вокруг данных, соблюдается процедурный стиль. Фактически, технология проектирования хороших процедур должна теперь применяться к каждой процедуре модуля.

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

Возможным внешним интерфейсом к модулю со стеком может быть:

     //определение интерфейса к модулю
     //стек символов
     char pop ();
     void push (chav);
     const stack-size=100;
  

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

     #include "stack.h"
     Static char v[stack-size]; //"static" означает, что переменная
                               //является локализованной в этом
                              //файле (модуле
     static char* P=V;       //стек вначале пуст
     char pop ()
     {
       //проверить, не пуст ли стек, и pop
     }
       //проверить, не переполнен ли стек, и push
     }
  

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

     # include "stack.h"
     void some-function ()
     {
       char c = pop(push ('c'));
       if (c!='c') error ("impossible");
     }
  

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

С языком С дела в этом смысле обстоят лучше. Как было показано, вы можете определить модуль, группируя процедуры и определения соответствующих данных в простом исходном файле. А затем программист может управлять и использованием данных в остальных частях программы (имя становится недоступным, если его описать в программе, как static). Таким образом в С может быть достигнута степень модульности. Однако такой путь, основанный на static-декларациях, является довольно низкоуровневым.

В одном из Pascal-подобном языке - Modula-2 - пошли несколько дальше. В нем формализация понятия модуля происходит путем определения модуля как фундаментальной конструкции с хорошо определенными декларациями, явным контролем всей совокупности используемых имен (средства импорта/экспорта), механизмом инициализации модуля и множеством общеизвестных допускаемых стилей программирования.

Другими словами, в С имеются средства программы на модули, в то время как Modula-2 поддерживает эту возможность.

АБСТРАКЦИЯ ДАННЫХ. Модульное программирование ведет к централизации контроля за всеми данными определенного типа в модуле управления типами данных. Если вам необходимо два стека, то вы можете определить управляющий модуль с интерфейсом такого вида:

     //stack-id это тип; никаких других подробностей
     //stack или stack-ids здесь доступны:
     class stack-id;
     //организовать стек и вернуть его идентификатор
     stack-id create-stack (int size);
     //обратиться, когда стек больше не нужен
     destroy-stack (stack-id);
     void push (stack-id,char);
     char pop (stack-id);
  

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

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

Например:

     void f ()
     {
       stack_id s1;
       stack_id s2;

       sl=create_stack (200);
       //Oops:забыли создать S2

       char c1=pop(s1,push(s1,'a'));
       if (c1!='c')error("impossible");

       chavc2=pop(s2,push(s2,'a'));
       if(c2!='c')error("impossible");

       destroy(s2);
       //Oops:забыли разрушить s1
     }
  

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

АБСТРАКТНЫЕ ТИПЫ ДАННЫХ. В таких языках, как Ada, Clu, С++, проблема абстрактных типов данных решается путем предоставления пользователю возможностей определения типов, которые ведут себя почти таким же образом, как встроенные типы. Типы такого вида часто называются абстрактными типами данных, хотя я предпочитаю называть их типами, определенными пользователем. (Как отмечал Дуг Маклрой (Doud Mellroy), эти типы не являются абстрактными, они так же реальны, как типы inf или real. Другое определение абстрактных типов данных требует математического определения всех типов (как встроенных, так и определенных пользователем). В этой статье мы будем понимать под такими типами данных конкретные спецификации таких действительно абстрактных объектов.) Здесь парадигма программирования следующая:"Решите, какие типы вам нужны; обеспечьте полный набор операций для каждого типа".

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

     class complex{
        double re,im;
     public:
        complex(double r,double ){re=r;im=i;}
     // преобразование float complex:
        complex(double r){re=r;im=0}
        friend complex operator+(complex,complex);
     // бинарный минус:
        friend complex operator-(complex,complex);
     // унарный минус:
        friend complex operator * (complex);
        friend complex operator/(complex,complex);
     //...
     }
  

Декларация комплексного класса (определенный пользователем тип) классифицирует представление комплексного числа и множество операций под такими числами. Представление является личным, т.е. re и im доступны только функциям, специфицированным в декларации комплексного класса. Такие функции можно определить так:

     complex operator+(complex a1, complex a2)
     {
      return complex (a1.re+a2.re,a1.im+a2.im);
     }
  

и использовать так:

     complex a=2.3;
     complex b=1/a;
     complex c=a+b*complex(1,2,3);
     //...
     с=-(а/в)+2;
  

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

ПРОБЛЕМЫ. Определяемый пользователем тип является черным ящиком. Будучи однажды определенным, он в действительности никак не взаимодействует с остальной частью программы. Единственным способом адаптации типа к новым применениям является его переопределение. Это, часто, очень негибкий способ.

Рассмотрим определяемый для использования в графике тип shape.Предположим на время, что система должна поддерживать окружности, треугольники и квадраты. Допустим также, что у вас есть ряд классов:

     class point{/*...*/};          (point - точка)
     class color{/*...*/};          (color - цвет)
  

Можно определить тип форма - shape - как:

     enum Kind{cirele,triangle,sguare};   (сircle -круг,
                                          triaugle -треугольник,
                                          squre - квадрат)

     class shape{
           point center;
           coljr col;
           kind k;
           //представление формы
     public:
           point where() {returu center;}
           void move (point to){cenre=to;draw();}
           void draw();
           void rotate (int);
           //другие операции
     };
  

Тип field, k используется в таких операциях, как draw() - рисовать и rotate() - вращать, для определения формы, с которой они имеют дело (в языках типа Pascal можно использовать иную запись с тегом k-tag k).

Функцию draw() можно определить так:

     void shape draw()
     {
     switch (k){
     case circle:
         //рисовать круг
           break;
     case triangle:
        //рисовать треугольник
          break;
     case square:
        //рисовать квадрат
     }
     }
  

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

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

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

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

ОБЪЕКТНО-ОРИЕНТИРОВАННОЕ ПРОГРАММИРОВАНИЕ

Возможности выразить отличия между представителями типа и воспользоваться преимуществами этого отличает объектно-ориентированное программирование.

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

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

     class shape{
           point center;
           color col;
           //...
     public:
           point where () {return center;}
           void move (point to) {center=to;draw();}
           virtual void draw()ж
           мшкегфд мщшв кщефеу(int);
           //...
     };
  

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

     void rotate-all (shape*V,int size,int augle)
         //вращать все элементы вектора "v"
         //значения "размеры-size","угол-augle"
        {
           tor (int i=0;iv1(100);//v1-вектор из 100 целых чисел
     vectorv2(200);//v2-вектор из 200 комплексныхчисел
     v2[i]=complex(v1[x],v1[y]);
  

В языках Ada и Clu поддерживаются параметризовнные типы. К сожалению в С++ этого средства нет; приведенные примеры использовали экспериментальные конструкции языка. Когда в программе встречаются параметризованные классы, они подменяются макросами. В случае, если все используемые типы явно определены, на стадии выполнения дополнительные накладные расходы, связанные с использованием классов, не возникают.

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

     cannot define
     vector::operator[](non_copy z):
        type noncopy does not have operator=
  

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

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

ОБРАБОТКА ОШЫБОК.По мере увеличения размеров программ и интенсивности использования библиотек, становится важной стандартизация обработки ошибок (или исключительных ситуаций).

В языках Ada,Algol-68,Clu есть средства стандартизованной обработки ошибок. В С++ таких средств, к сожалению нет. Если возникает необходимость, ошибочные ситуации обрабатываются с использованием указателей к функциям, ошибочных состояний и средств библиотеки языка Си signal и longjmp. Это все является явно неудовлетворительным, потому что даже не может обеспечить стандартную схему обработки ошибок.

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

     class vector{
        ...
     except vector-range{
        //определить ошибочную ситуацию,
        //называемую vector-range и специфицировать
        //программу для ее обработки
        error("global:vector range error");
        exit(99);
     }
     }
  

Вместо обращения к функции обработки ошибок error, vector::operator[]() может генерировать код ошибки:

     intz vector::operator[](int i)
     {
        if (0 < I и можно ... int } вектора?);
     a = b + complex (2);
     a = b + 2;   //неявно:
                  //2->complex(2)
  

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

Один способ использования преобразований оказался особенно полезным при организации программ:

     complex a=2;
     complex b=a+2; //интерпретируется как
                    //оператор + (а,complex(2))
     b = 2 + a;     //интерпретируется как
                    //оператор + (cjmplex(2),a)
  

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

Это контрастирует с "чистой" объектно-ориентированной системой программирования, где операции интерпретируются следующим образом:

     a + 2;//a.operator + (2)
     2 + a;//2.operator + (a),
  

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

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

ПОВТОРИТЕЛИ(iterators). Язык, который поддерживает абстракцию данных, должен обеспечивать способ определения управляющих структур [4]. В частности, пользователям необходим механизм определения циклов с элементами, содержащимися в объекте некоторого определенного пользователем типа, вне зависимости от особенностей реализации пользовательского типа. При наличии достаточно мощного механизма для определения новых типов и операторов перегрузки это можно сделать без введения отдельного механизма определения управляющих структур.

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

Существует несколько стилей итерирования. Предпочитаемый мной опирается на перегрузку прикладного оператора функции ():

     class vector iterator{
        vector z v
        int i;
     public:
        vector_iterator(vector z r){i=0;v=r;}
        int operator ()()
        {return i < V.SIZE()?V.ELEM(I++):0;} class="" 
  

В таких языках, как С++ и Simula, где широко используется статическая прверка типов, система поддержки типов может использовать различные механизмы вызова. В С++ есть две альтернативы:

  1. ОБЫЧНОЕ ОБРАЩЕНИЕ К ФУНКЦИИ:
  2. нужная функция определяется во время компиляции (просмотром таблицы символов компилятора); обращение к ней происходит с помощью обычного call-механизма с использованием аргумента, идентифицирующего объект, для которого нужна вызываемая функция. В случаях, когда стандартный call-механизм не эффективен в достаточной мере, программист может указать, что функцию следует прямо встраивать в код программы в месте обращения к ней. Это позволяет достигнуть эффективности макрорасширений, не нарушая стандартной семантики обращения к функциям. Такая оптимизация равно годится и в случае абстракции данных.

  3. ВИРТУАЛЬНОЕ ОБРАЩЕНИЕ К ФУНКЦИИ:
  4. вызов функции зависит от типа объекта, который обычно можно определить только во время выполнения программы. Типичной является ситуация, когда указатель Р связан с некоторым базовым классом В, а объект относится к некоторому производному классу D.Call-механизм должен"заглянуть"в объект, найти помещенную туда компилятором информацию и определить, к какой служебной функции следует обратиться. Как только соответствующая функция, скажем D::F, найдена, для обращения к ней использутся выше описанный механизм. На стадии компиляции имя F преобразуется в индекс к таблице указателей к функциям. Такой виртуальный Call-механизм может быть сделан таким же эффективным, как и обычный. В стандартной реализации языка С++, только пять ссылок на дополнительную память. В случаях, когда тип объекта можно определить во время компиляции, можно исключить даже эти накладные расходы и использовать средства встраивания кода функции в код программы. Такие случаи являются достаточно общими и важными.

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

  5. ОБРАЩЕНИЕ К СЛУЖЕБНОЙ УТИЛИТЕ:
  6. вначале ищется соответствующая таблица имен сдужебных утилит с помощью анализа описания объекта, на который указывает указатель Р. В этой таблице (или множестве таблиц) ищется строка F, если объект содержит F(). Если F() обнаруживается, то к ней происходит обращение; иначе обрабатывается ошибочная ситуация. Этот просмотр отличается от просмотра, проводимого на стадии компиляций в языках со статической проверкой типов, потому что для обращения к служебной утилите используется таблица служебных утилит для актуального объекта. Описанный способ является неэффективным по сравнению с виртуальным Call-обращением, но более гибким. Так как чаще всего статическая проверка аргументов типов не может быть выполнена при обращении к служебной утилите, использование механизма служебных утилит должно обеспечиваться динамической проверкой типов.

ПРОВЕРКА ТИПОВ.Приведенный пример с формами показал мощь виртуальных функций. Что еще предоставляет программисту механизм обращения к служебной утилите? Он позволяет использовать любую служебную утилиту для любого объекта.

Эта возможность позволяет разработчику библиотеки функций общего назначения перенести ответственность по обработке типов на плечи пользователя. Естественно это облегчает проектирование библиотеки. Например:

     class stack {  // предположим класс any
                    // содержит функцию next
     any*v;

     void push (anyx p)
     {
        p >next = v
        v = p;
     }
     any*pop ()
     {
        if(v==0)return error_obj;
        ani*r=v;
        v=v->next;
        return r;
     }
     };
  

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

     Stackcs;
     cs.push(new Saab 900);
     cs.push(new Saab 37B);
     plane*p=(plane*)cs.pop();
     p->takeoff();p=(plane*)cs.pop();
     p->takeoff();
        //ошибка на стадии выполнения;
        //Saab 900 это автомобиль
        //автомобиль не имеет служебной утилиты takeoff
  

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

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

     stackcs;
     cs.push(new Saab 900);
        //Ошибка на стадии компиляции: смешение типов;
        //используется car*, ожидается plane*
     cs.push (new Saab 37 B);
     plane*p=cs.pop();
     p->takeoff(); //ошибкаЖ Saab 37 B это самолет
     p=cs.pop();
     p->takeoff();
  

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

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

МЕХАНИЗМ НАСЛЕДОВАНИЯ. Рассмотрим язык, в котором реализована некоторая форма просмотра служебных утилит без использования механизмов наследования. Поддерживает ли такой язык объектно-ориентированное программирование? Я думаю, что нет.

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

Рассмотрим язык, в котором обеспечивается механизм наследования, но не включены возможности виртуальных функций или служебных утилит. Поддерживает ли такой язык объектно-ориентированное программирование? Я думаю, что нет: в таком языке трудно предложить хорошее решение для примера с формами.

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

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

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

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

Средство производных классов является одним из програмистских инструментариев. Для него не существует строгих рекомендаций по использованию - этот подход еще слишком молод (на 20 лет моложе языка Simula), чтобы можно было говорить о том, что какие-то его применения являются надуманными.

МЕХАНИЗМ МНОГОСЕТЕВОГО НАСЛЕДОВАНИЯ. Если класс А является базовым для класса В, то В наследует атрибуты А, т.е. В обладает свойствами А плюс, возможно, некоторыми другими особенностями. Приняв такое пояснение, кажется очевидным, что могла бы оказаться полезной возможность существования двух базовых классов А1 и А2 для кдасса В. Это называется множественным наследованием.

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

     class my-displayed-task
     :public displayed, public task{
        //мое"хозяйство"
     };
     class my-task
     :public task{//мое "хозяйство"
                  //не выводимое на дисплей
     };
     class my-displayed
     :public displayed{//не задача
     };
  

В случае единичного наследования программисту открыты только две из этих трех возможностей. Это ведет к дублированию программного кода или потере гибкости, а чаще всего-и того, и другого. В С++ этот пример может быть реализован без значительных накладных расходов (по времени и памяти), сравнимых с единичным наследованием и без отказа от статической проверки типов [9].

Неопределенности обнаруживаются во время компиляции:

     class A {public:f();...};
     class B {public:f();...};
     class C:public A, public B {...};

     void g(){
          c*p;
          p->f();///ошибка:двусмысленность
  

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

В С++ типичным путем разрешения неопределенности является добавление функции:

     class C:public A, public B{
     public:
        f()
        {
             //"хозяйство" класса С
            A::f();
            B::f();
         }
         ...
         }
  

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

     class W {...};
     class B window //окно с границей
     :public virtual W
     {...};
     class M window //окно с меню
     :public virtual W
     {...};
     class BMW       //окно с границей и меню
     :public B window, public M window
     {...}
  

Здесь единичный подобъект "окно" разделяется подобъектами В window и M window класса BMW.В диалектике Lisp для облегчения программирования с использованием таких сложных иерархий классов применяется комбинирование служебных утилит. В С++ в этом нет необходимости.

ИНКАПСУЛЯЦИЯ. Рассмотрим элемент класса (данные или функцию), которые следует защитить от неавторизованного доступа. Какие решения приемлемы, чтобы ограничить доступ к этому элементу?

К сожалению решение, принятое в языках, поддерживающих абстракцию данных, отличается от приведенного нами:"Перечислите все функции, для которых необходим доступ к элементу, в декларации класса". При этом ничего не говорится о том, что это за функции,- они не обязательно должны быть функциями, описанными в классе. Неописанные в классе функции с доступам к элементам класса в С++ называются дружественными. Упомянутый ранее класс Complex был определен с использованием дружес твенных функций. Иногда важно, чтобы можно было определить функцию как дружественную для более чем одного класса. Доступность полного списка описанных в классе и дружественных функций является большим преимуществом, когда вы пытаетесь понять поведение типа и в особенности, когда вы хотите модифицировать его.

Рассмотрим пример, который демонстриует некоторые из возможных путей инкансуляции в С++:

     class B{
             //члены класса по умолчанию
             //личного пользования
        int i1;
        void f1();
     protected:
        int i2;
     publik:
        int i3;
        void f3();
     friend void g (B*); //любая функция может
                         //быть определена как
                         //дружественная
     };
  

Личные и защищенные члены класса вообще не являются доступными:

     void h (B*p)
     {
        p->f1(); //ошибка: В::f1-личная
        р->f2(); //ошибка: B::f2-защищенная
        p->f3(); //окей  : B::f3-общего пользования
     }
  

Запрещенные, но не личные, члены доступны членам производных классов:

     class D:public B{
     public:
        void g()
        {
           f1(); //ошибка: B::f1-личная
           f2(); //окей  : B::f2-защищенная,
                 //но D получен из В
           f3(); //окей  : B::f3-общего пользования
         }
     };
  

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

     void g(B*p)
     {
        p->f1(); //окей: B::f1-личная
                 //но g() дружественна В
        p->f2(); //окей: B::f2-защищенная,
                 //но g()дружественна В
        p->f3(); //окей :B::f3-общего пользования
     }
  

Важность средств инкапсуляции резко возрастает по мере увеличения размеров программ, а также увеличения количества пользователей и расширения сферы их географического размещения. Детали о механизмах инкапсуляции можно найти у Шнайдера (Snyder)[6] и Строустрапа (Stroustrup)[7].

ОСОБЕННОСТИ РЕАЛИЗАЦИИ

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

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

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

ПРОБЛЕМЫ

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

Это означает, что должны быть включены средства для эффективных численных приложений (плавающая арифметика без накладных расходов, иначе Fortran окажется привлекательней). Должны быть включены возможности доступа к памяти (что необходимо для написания дрейверов). Должны быть возможности обращени[я к функциям (call-обращения), согласованные с интерфейсами конкретных операционных систем. И, дополнительно, должны быть возможности обращения к функциям, написанным на других языках и наоборот, к функциям, написанным на объектно-ориентированных языках из других языков.

Это также означает, что объектно-ориентированный язык не может полностью основываться не механизмах, которые эффективно не реализуются на традиционных архитектурах, и что все еще предполагается использование такого языка, как языка общего назначения. То же можно сказать и о сборке мусора, которая может оказаться узким местом в части производительности и мобильности. Большинство объектно-ориентированных языков используют сборку мусора, чтобы упростить проблемы программиста и уменьшить сложность самого языка и компилятора. Однако должна быть возможность использовать сборку мусора в некритических ситуациях, однако сохранять контроль за памятью, там, где это необходимо. Альтернативой является язык, не занимающийся сборкой мусора, но позволяющий проектировать типы, которые управляют используемой ими памятью. Примером может служить С++.

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

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

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

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

БЛАГОДАРНОСТИ

Ранняя версия этой статьи представлялась на совещании Ассоциации пользователей языка Simula-association of Simula Users - в Стокгольме, прошедшем в августе 1986 г. Прошедшая там дискуссия внесла много улучшений в стиль излождения и содержания статьи. Много конструктивных замечаний сделали Брайен Керниган (Brian Kernighan) и Рави Сети (Ravi Sethi).


                         Л и т е р а т у р а

    1.K.Nygaard,"Basic Cocepts in Object-Oriented Programming",
      SIGPlan  Notices,Oct.1986,pp.128-132.

    2.R.Kerr,"Object-Based Programming:A.Foundation for Reliable
      Software,"Proc.14th Simulu Users'Conf.,Simula Information,Oslo,
      Norway,1986,pp.159-165;a short version is "A Materialistic View
      of the Sofware 'Engineering' Analogy, SIGPlan Notices, March
      1987,pp123-125.

    3.T.Cargill,"IPI:A Case Study in Object-Oriented Programming",
      SIGPlan Ntices, Nov.1986,pp.350-360.

    4.B.Liskov et al.,"Abstraction Mechanisms in Clu,"Comm.ACM,
      Aug.1977,pp.564-576.

    5.J.Shopiro,"Extending the C++ Task System for Real-Time Appli-
      cations,"Proc.Usenix C++ Workshop, Usenix, Santa Monica,Calif.,
      1987,pp.77-94.

    6.A.Snyder, "Encapsulation and Inheritance in Object-Oriented
      Programming Languages,"SIGPlan Notices,Nov.1986,pp.38-45.

    7.B.Stroustrup, The C++ Programming Language, Addison-Wesley,
      Reading,Mass.,1986.

    8.D.Weinreb and D.Moon, Lisp Manual,Symbolics,Cam-
      bridge, Mass.,1981.

    9.B.Stroustrup, "Multiple Inheritance for C++, "Proc. Spring
      European Unix Users Group Conf., EEUG,London,1987.
  
* * *

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

Stroustrup получил MS в области математики и вычислительной техники в университете Артуса (Aarhus) и PhD по вычислительной технике в университете Кэмбриджа (Cambridge). Он является членом исследовательского центра вычислительной техники (Computer Science Research Center), также членом IEEE и ACM.

Вопросы, касающиеся этой статьи, направляйте автору в АТ$Т Bell Gaboratovies, Rm.2C-324, 600 Monntain Ave.,Murray Hill, N J 07974.