<< Пред. стр. 84 (из 121) След. >>
Список литературы по разделу
Requested query: ( untamed || ( fiery || ( shyly ) ) )
( 3 ) like a fiery bird in flight. A beautiful fiery bird, he tells her,
( 4 ) magical but untamed. "Daddy, shush, there is no such thing,"
( 6 ) Shyly, she asks, "I mean, Daddy, is there?"
Реализация print() для класса NameQuery:
ostream&
NameQuery::
print( ostream &os ) const
{
if ( _lparen )
print_lparen( _lparen, os );
os << _name;
if ( _rparen )
print_rparen( _rparen, os );
return os;
}
А так выглядит объявление:
class NameQuery : public Query {
public:
virtual ostream& print( ostream &os ) const;
// ...
};
Чтобы реализация виртуальной функции в производном классе замещала реализацию из базового, прототипы функций обязаны совпадать. Например, если бы мы опустили слово const или объявили еще один параметр, то реализация print() в NameQuery не заместила бы реализацию из базового класса. Возвращаемые значения также должны быть одинаковыми за одним исключением: значение, возвращенное реализацией в производном классе, может принадлежать к типу класса, который открыто наследует классу значения, возвращаемого реализацией в базовом классе. Если бы реализация из базового класса возвращала значение типа Query*, то реализация из производного могла бы возвращать NameQuery*. (Позже при работе с функцией clone() мы покажем, зачем это нужно.) Вот объявление и реализация print() в NotQuery:
class NotQuery : public Query {
public:
virtual ostream& print( ostream &os ) const;
// ...
};
ostream&
NotQuery::
print( ostream &os ) const
{
os << " ! ";
if ( _lparen )
print_lparen( _lparen, os );
_op->print( os );
if ( _rparen )
print_rparen( _rparen, os );
return os;
}
Разумеется, вызов print() через _op – виртуальный.
Объявления и реализации этой функции в классах AndQuery и OrQuery практически дублируют друг друга. Поэтому приведем их только для AndQuery:
class AndQuery : public Query {
public:
virtual ostream& print( ostream &os ) const;
// ...
};
ostream&
AndQuery::
print( ostream &os ) const
{
if ( _lparen )
print_lparen( _lparen, os );
_lop->print( os );
os << " && ";
_rop->print( os );
if ( _rparen )
print_rparen( _rparen, os );
return os;
}
Такая реализация виртуальной функции print() позволяет вывести любой подтип Query в поток класса ostream или любого другого, производного от него:
cout << "Был сформулирован запрос ";
Query *pq = retrieveQuery();
pq->print( cout );
Однако такой возможности недостаточно. Еще нужно уметь распечатывать любой производный от Query тип, который уже есть или может появиться в будущем, с помощью оператора вывода из библиотеки iostream:
Query *pq = retrieveQuery();
cout << "В ответ на запрос "
<< *pq
<< " получены следующие результаты:\n";
Мы не можем непосредственно предоставить виртуальный оператор вывода, поскольку они являются членами класса ostream. Вместо этого мы должны написать косвенную виртуальную функцию:
inline ostream&
operator<<( ostream &os, const Query &q )
{
// виртуальный вызов print()
return q.print( os );
}
Строки
AndQuery query;
// сформулировать запрос ...
cout << query << endl;
вызывают наш оператор вывода в ostream, который в свою очередь вызывает
q.print( os )
где q привязано к объекту query класса AndQuery, а os – к cout. Если бы вместо этого мы написали:
NameQuery query2( "Salinger" );
cout << query2 << endl;
то была бы вызвана реализация print() из класса NameQuery. Обращение
Query *pquery = retrieveQuery();
cout << *pquery << endl;
приводит к вызову той функции print(), которая ассоциирована с объектом, адресуемым указателем pquery в данной точке выполнения программы.
17.5.2. Чисто виртуальные функции
С точки зрения кодирования основная задача, стоящая перед нами в связи с поддержкой пользовательских запросов, – это реализация зависимых от типа операций для каждого из возможных операторов. Для этого мы определили четыре конкретных типа классов: AndQuery, OrQuery и т.д. Однако с точки зрения проектирования наша цель – инкапсулировать обработку каждого вида запроса, спрятать за не зависящим от типа интерфейсом. Это позволит построить ядро приложения, которое не потребует изменений при добавлении или удалении типов.
Чтобы добиться этого, определим абстрактный тип класса Query. При этом мы не будем программировать разные типы пользовательских запросов, а лишь абстрактные операции, применимые к ним:
void doit_and_bedone( vector< Query* > *pvec )
{
vector
::iterator
it = pvec->begin(),
end_it = pvec->end();
for ( ; it != end_it; ++it )
{
Query *pq = *it;
cout << "обрабатывается " << *pq << endl;
pq->eval();
pq->display();
delete pq;
}
}
Такое определение позволяет добавлять неограниченное число типов запросов без необходимости изменять или даже перекомпилировать ядро системы, но при условии, что открытый интерфейс нашего абстрактного базового класса Query достаточен для поддержки новых запросов.
Проектируя открытый интерфейс Query, мы определим множество операций, достаточное для поддержки всех существующих и будущих типов запросов, хотя на практике нам вряд ли удастся это гарантировать. Предоставление общего интерфейса для тех запросов, о которых мы уже знаем, – вполне реальная задача, но любое заявление, претендующее на более широкую поддержку, следует рассматривать с долей скептицизма.
Поскольку Query – абстрактный класс, объекты которого в приложении не создаются, то никакой разумной реализации виртуальных функций в нем самом мы предложить не можем. Это лишь названия, которые должны быть замещены в производных классах. Напрямую вызывать их мы не будем.
Язык обладает синтаксической конструкцией, обозначающей, что некоторая виртуальная функция предоставляет интерфейс, который должен быть замещен в производных подтипах, но вызываться непосредственно не может. Это чисто виртуальные функции. Объявляются они следующим образом:
class Query {
public:
// объявляется чисто виртуальная функция
virtual ostream& print( ostream&=cout ) const = 0;
// ...
};
Заметьте, что за объявлением функции следует присваивание нуля.
Класс, содержащий (или наследующий) одну или несколько таких функций, распознается компилятором как абстрактный базовый класс. Попытка создать независимый объект абстрактного класса приводит к ошибке компиляции. (Ошибкой является также вызов чисто виртуальной функции с помощью механизма виртуализации.) Например:
// В классе Query объявлены одна или несколько виртуальных функций,
// поэтому программист не может создавать независимые объекты
// класса Query
// правильно: подобъект Query в составе NameQuery
Query *pq = new NameQuery( "Nostromo" );
// ошибка: оператор new создает объект класса Query
Query *pq2 = new Query;
Абстрактный базовый класс может существовать только как подобъект в составе объекта некоторого производного от него класса. Это именно та семантика, которая нужна нам для базового Query.
17.5.3. Статический вызов виртуальной функции
Вызывая виртуальную функцию с помощью оператора разрешения области видимости класса, мы отменяем механизм виртуализации и разрешаем вызов статически, на этапе компиляции. Предположим, что мы определили виртуальную функцию isA() в базовом и каждом из производных классов иерархии Query:
Query *pquery = new NameQuery( "dumbo" );
// isA() вызывается динамически с помощью механизма виртуализации
// реально будет вызвана NameQuery::isA()
pquery->isA();
// isA вызывается статически во время компиляции
// реально будет вызвана Query::isA
pquery->Query::isA();
Тогда явный вызов Query::isA() разрешается на этапе компиляции в пользу реализации isA() в базовом классе Query, хотя pquery адресует объект NameQuery.
Зачем нужно отменять механизм виртуализации? Как правило, ради эффективности. В теле виртуальной функции производного класса часто необходимо вызвать реализацию из базового, чтобы завершить операцию, расщепленную между базовым и производным классами. К примеру, вполне вероятно, что виртуальная функция display() из Camera выводит некоторую информацию, общую для всех камер, а реализация display() в классе PerspectiveCamera сообщает информацию, специфичную только для перспективных камер. Вместо того чтобы дублировать в ней действия, общие для всех камер, можно вызвать реализацию из класса Camera. Мы точно знаем, какая именно реализация нам нужна, поэтому нет нужды прибегать к механизму виртуализации. Более того, реализация в Camera объявлена встроенной, так что разрешение во время компиляции приводит к подстановке по месту вызова.
Приведем еще один пример, когда отмена механизма виртуализации может оказаться полезной, а заодно познакомимся с неким аспектом чисто виртуальных функций, который начинающим программистам кажется противоречащим интуиции.
Реализации функции print() в классах AndQuery и OrQuery совпадают во всем, кроме литеральной строки, представляющей название оператора. Реализуем только одну функцию, которую можно вызывать из данных классов. Для этого мы снова определим абстрактный базовый BinaryQuery (его наследники – AndQuery и OrQuery). В нем определены два операнда и еще один член типа string для хранения значения оператора. Поскольку это абстрактный класс, объявим print() чисто виртуальной функцией:
class BinaryQuery : public Query {
public:
BinaryQuery( Query *lop, Query *rop, string oper )
: _lop(lop), _rop(rop), _oper(oper) {}
~BinaryQuery() { delete _lop; delete _rop; }
ostream &print( ostream&=cout, ) const = 0;
protected:
Query *_lop;
Query *_rop;
string _oper;
};
Вот как реализована в BinaryQuery функция print(), которая будет вызываться из производных классов AndQuery и OrQuery:
inline ostream&
BinaryQuery::
print( ostream &os ) const
{
if ( _lparen )
print_lparen( _lparen, os );
_lop->print( os );
os << ' ' << _oper << ' ';
_rop->print( os );
if ( _rparen )
print_rparen( _rparen, os );
return os;
}
Похоже, мы попали в парадоксальную ситуацию. С одной стороны, необходимо объявить этот экземпляр print() как чисто виртуальную функцию, чтобы компилятор воспринимал BinaryQuery как абстрактный базовый класс. Тогда в приложении определить независимые объекты BinaryQuery будет невозможно.
С другой стороны, нужно определить в классе BinaryQuery виртуальную функцию print() и уметь вызывать ее через объекты AndQuery и OrQuery.
Но как часто бывает с кажущимися парадоксами, мы не учли одного обстоятельства: чисто виртуальную функцию нельзя вызывать с помощью механизма виртуализации, но можно вызывать статически:
inline ostream&
AndQuery::
print( ostream &os ) const
{
// правильно: подавить механизм виртуализации
// вызвать BinaryQuery::print статически
BinaryQuery::print( os );
}
17.5.4. Виртуальные функции и аргументы по умолчанию
Рассмотрим следующую простую иерархию классов:
#include
class base {
public:
virtual int foo( int ival = 1024 ) {
cout << "base::foo() -- ival: " << ival << endl;
return ival;
}
// ...
};
class derived : public base {
public:
virtual int foo( int ival = 2048 ) {
cout << "derived::foo() -- ival: " << ival << endl;
return ival;
}
// ...
};
Проектировщик класса хотел, чтобы при вызове без параметров реализации foo() из базового класса по умолчанию передавался аргумент 1024:
base b;
base *pb = &b;
// вызывается base::foo( int )
// предполагалось, что будет возвращено 1024
pb->foo();
Кроме того, разработчик хотел, чтобы при вызове его реализации foo() без параметров использовался аргумент по умолчанию 2048:
derived d;
base *pb = &d;
// вызывается derived::foo( int )
// предполагалось, что будет возвращено 2048
pb->foo();
Однако в C++ принята другая семантика механизма виртуализации. Вот небольшая программа для тестирования нашей иерархии классов:
int main()
{
derived *pd = new derived;
base *pb = pd;
int val = pb->foo();
cout << "main() : val через base: "
<< val << endl;
val = pd->foo();
cout << "main() : val через derived: "
<< val << endl;
}
После компиляции и запуска программа выводит следующую информацию:
derived::foo() -- ival: 1024
main() : val через base: 1024
derived::foo() -- ival: 2048
main() : val через derived: 2048
При обоих обращениях реализация foo() из производного класса вызывается корректно, поскольку фактически вызываемый экземпляр определяется во время выполнения на основе типа класса, адресуемого pd и pb. Но передаваемый foo() аргумент по умолчанию определяется не во время выполнения, а во время компиляции на основе типа объекта, через который вызывается функция. При вызове foo() через pb аргумент по умолчанию извлекается из объявления base::foo() и равен 1024. Если же foo() вызывается через pd, то аргумент по умолчанию извлекается из объявления derived::foo() и равен 2048.
Если реализации из производного класса при вызове через указатель или ссылку на базовый класс по умолчанию передается аргумент, указанный в базовом классе, то зачем задавать аргумент по умолчанию для реализации из производного класса?
Нам могут понадобиться различные аргументы по умолчанию в зависимости не от реализации foo() в конкретном производном классе, а от типа указателя или ссылки, через которые функция вызвана. Например, значения 1024 и 2048 – это размеры изображений. Когда нужно получить менее детальное изображение, вызываем foo() через класс base, а когда более детальное – через derived.
Но если мы все-таки хотим, чтобы аргумент по умолчанию, передаваемый foo(), зависел от фактически вызванного экземпляра? К сожалению, механизм виртуализации такую возможность не поддерживает. Однако разрешается задать такой аргумент по умолчанию, который для вызванной функции означает, что пользователь не передал никакого значения. Тогда реальное значение, которое функция хотела бы видеть в качестве аргумента по умолчанию, объявляется локальной переменной и используется, если ничего другого не передано:
void
base::
foo( int ival = base_default_value )
{
int real_default_value = 1024; // настоящее значение по умолчанию
if ( ival == base_default_value )
ival = real_default_value;
// ...
}
Здесь base_default_value – значение, согласованное между всеми классами иерархии, которое явно говорит о том, что пользователь не передал никакого аргумента. Производный класс может быть реализован аналогично:
void
derived::
foo( int ival = base_default_value )
{
int real_default_value = 2048;
if ( ival == base_default_value )
ival = real_default_value;
// ...
}
17.5.5. Виртуальные деструкторы
В данной функции мы применяем оператор delete:
void doit_and_bedone( vector< Query* > *pvec )
{
// ...
for ( ; it != end_it; ++it )
{
Query *pq = *it;
// ...
delete pq;
}
}
Чтобы функция выполнялась правильно, применение delete должно вызывать деструктор того класса, на который указывает pq. Следовательно, необходимо объявить деструктор Query виртуальным:
class Query {
public:
virtual ~Query() { delete _solution; }
// ...
};
Деструкторы всех производных от Query классов автоматически считаются виртуальными. doit_and_bedone() выполняется правильно.
<< Пред. стр. 84 (из 121) След. >>
Список литературы по разделу