C++. Сборник рецептов полностью

 virtual string getLastName() {return(lastName_);}

protected:

 string firstName_;

 string lastName_;

};

Теперь, если подкласс Superhero хочет переопределить одну из этих функций, то он может это сделать. Все, что он должен сделать, чтобы указать, какая версия должна вызываться, — это использовать имя базового класса. Например:

string Superhero::getLastName() {

 return(Person::getLastName() + " (Superhero)");

}

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

class Person {

 // ...

 virtual void setFirstName(const string& s) = 0;

 // ...

 Person::setFirstName(const string& s) {

  firstName_ = s;

 }

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

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

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

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

Пример 8.12. Написание шаблона класса

#include

#include

using namespace std;

template

class TreeNode {

public:

 TreeNode (const T& val) : val_(val), left_(NULL), right_(NULL) {}

 ~TreeNode() {

  delete left_;

  delete right_;

 }

 const T& getVal() const {return(val_);}

 void setVal(const T& val) {val_ = val;}

 void addChild(TreeNode* p) {

  const T& other = p->getVal();

  if (other > val_)

   if (rights)

    right_->addChild(p);

   else

    right_ = p;

  else

   if (left_)

    left_->addChild(p);

   else

    left_ = p;

 }

 const TreeNode* getLeft() {return(left_);}

 const TreeNode* getRight() {return(right_);}

private:

 T val_;

 TreeNode* left_;

 TreeNode* right_;

};

int main() {

 TreeNode node1("frank");

 TreeNode node2("larry");

 TreeNode node3("bill");

 node1.addChild(&node2);

 node1.addChild(&node3);

}

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

Рассмотрим объявление шаблона класса TreeNode из примера 8.12.

template class TreeNode {

//...

Часть template — это то, что делает этот класс шаблоном, а не обычным классом. Эта строка говорит, что T — это имя типа, который будет указан при использовании класса, а не при его объявлении. После этого параметр T может использоваться в объявлении и определении TreeNode так, как будто это обычный тип — встроенный или определенный пользователем. Например, имеется частный член с именем val_, который должен иметь тип T. Тогда его объявление будет иметь вид:

T val_;

Здесь просто объявляется член класса с именем val_ некоторого типа, который будет определен позднее. Это объявление выглядит так же, как и при использовании для val_ типов int, float, MyClass или string. В этом отношении его можно рассматривать как макрос (т.е. использование #define), хотя сходство с макросом на этом и заканчивается.