Программирование >>  Поддержка объектно-ориентированного программирования 

1 ... 7 8 9 [ 10 ] 11 12 13 ... 120


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

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

complex a = 2;

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

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

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

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

template < class T > class stack

public:

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

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

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

stack < cat > s; ошибка: стек - абстрактный класс void some function ( stack <cat> & s, cat kitty ) нормально

s.push ( kitty ); cat c2 = s.pop (); ...

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

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

template < class T > class astack : public stack < T >

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

...

public:

astack ( int size ); ~astack (); void push ( T ); T pop ();

Можно реализовать стек как связанный список:



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

void g ()

lstack < cat > s1 ( 100 );

astack < cat > s2 ( 100 ); cat Ginger; cat Snowball;

some function ( s1. Ginger );

some function ( s2. Snowball );

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

1.5 Поддержка объектно-ориентированного программирования

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

1.5.1 Механизм вызова

Основное средство поддержки объектно-ориентированного программирования - это механизм вызова функции-члена для данного объекта, когда истинный тип его на стадии трансляции неизвестен. Пусть, например, есть указатель p. Как происходит вызов p->rotate(45)? Поскольку С++ базируется на статическом контроле типов, задающее вызов выражение имеет смысл только при условии, что функция rotate() уже была описана. Далее, из обозначения p->rotate() мы видим, что p является указателем на объект некоторого класса, а rotate должна быть членом этого класса. Как и при всяком статическом контроле типов проверка корректности вызова нужна для того, чтобы убедиться (насколько это возможно на стадии трансляции), что типы в программе используются непротиворечивым образом. Тем самым гарантируется, что программа свободна от многих видов ошибок.

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

class shape

...

public:

...

virtual void rotate ( int );

а указатель p должен быть описан, например, так:

template < class T > class lstack : public stack < T >



Функции из таблицы виртуальных функций vtbl позволяют правильно работать с объектом даже в тех случаях, когда в вызывающей функции неизвестны ни таблица vtbl, ни расположение данных в части объекта, обозначенной ... . Здесь как X и Y обозначены имена классов, в которые входят вызываемые функции. Для объекта circle оба имени X и Y есть circle. Вызов виртуальной функции может быть по сути столь же эффективен, как вызов обычной функции.

1.5.2 Проверка типа

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

template < class T > class stack

T * p;

int sz; public:

stack ( int );

~stack ();

void push ( T );

T & pop ();

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

stack < plane * > cs ( 200 );

void f ()

cs.push ( new Saab9 0 0 ); Ошибка при трансляции :

cs.push ( new Saab37B );

cs.pop () -> takeoff (); cs.pop () -> takeoff ();

требуется plane*, а передан car*

прекрасно: Saab 37B - на самом деле самолет, т.е. типа plane

T * p;

где T - класс shape или производный от него класс. Тогда транслятор видит, что класс объекта, на который настроен указатель p, действительно имеет функцию rotate(), а функция имеет параметр типа int. Значит, p->rotate(45) корректное выражение.

Поскольку shape::rotate() была описана как виртуальная функция, нужно использовать механизм вызова виртуальной функции. Чтобы узнать, какую именно из функций rotate следует вызвать, нужно до вызова получить из объекта некоторую служебную информацию, которая была помещена туда при его создании. Как только установлено, какую функцию надо вызвать, допустим circle::rotate, происходит ее вызов с уже упоминавшимся контролем типа. Обычно в качестве служебной информации используется таблица адресов функций, а транслятор преобразует имя rotate в индекс этой таблицы. С учетом этой таблицы объект типа shape можно представить так:

center vtbl:

color &X::draw

&Y::rotate



1 ... 7 8 9 [ 10 ] 11 12 13 ... 120

© 2006 - 2024 pmbk.ru. Генерация страницы: 0.001
При копировании материалов приветствуются ссылки.
Яндекс.Метрика