Для понимания шаблонов огромное преимущество состоит в том, чтобы уточнить терминологию, потому что то, как вы говорите о них, определяет способ их восприятия.
В частности, Area - это не шаблонный класс, а шаблон класса. То есть это шаблон, из которого можно генерировать классы. Area<int> - это такой класс (это , а не объект, но, конечно, вы можете создать объект из этого класса так же, как вы можете создавать объекты из любого другого класса). Другой такой класс будет Area<char>. Обратите внимание, что это совершенно разные классы, которые не имеют ничего общего, за исключением того факта, что они были сгенерированы из одного и того же шаблона класса.
Поскольку Area не является классом, вы не можете извлечь класс Rectangle из него. Вы можете получить класс только из другого класса (или нескольких из них). Поскольку Area<int> является классом, вы можете, например, получить Rectangle из него:
class Rectangle:
public Area<int>
{
// ...
};
Поскольку Area<int> и Area<char> - это разные классы, вы даже можете наследовать их от обоих одновременно (однако при доступе к их членам вам придется иметь дело с неясностями):
class Rectangle:
public Area<int>,
public Area<char>
{
// ...
};
Однако при определении Rectangle вы должны указать, какие из них следует получить. Это верно независимо от того, генерируются ли эти классы из шаблона или нет. Два объекта одного класса просто не могут иметь разные иерархии наследования.
Что вы можете сделать, так это сделать Rectangle шаблоном. Если вы напишите
template<typename T> class Rectangle:
public Area<T>
{
// ...
};
У вас есть шаблон Rectangle, из которого вы можете получить класс Rectangle<int>, производный от Area<int>, и другой класс Rectangle<char>, производный от Area<char>.
Возможно, вы хотите, чтобы у вас был один тип Rectangle, чтобы вы могли передавать все виды Rectangle в одну и ту же функцию (которая сама по себе не должна знать тип Area). Так как классы Rectangle<T>, сгенерированные путем создания экземпляра шаблона Rectangle, формально не зависят друг от друга, он не работает таким образом. Однако вы можете использовать множественное наследование здесь:
class Rectangle // not inheriting from any Area type
{
// Area independent interface
};
template<typename T> class SpecificRectangle:
public Rectangle,
public Area<T>
{
// Area dependent stuff
};
void foo(Rectangle&); // A function which works with generic rectangles
int main()
{
SpecificRectangle<int> intrect;
foo(intrect);
SpecificRectangle<char> charrect;
foo(charrect);
}
Если важно, чтобы ваш универсальный Rectangle был получен из универсального Area, вы можете проделать тот же трюк и с Area:
class Area
{
// generic Area interface
};
class Rectangle:
public virtual Area // virtual because of "diamond inheritance"
{
// generic rectangle interface
};
template<typename T> class SpecificArea:
public virtual Area
{
// specific implementation of Area for type T
};
template<typename T> class SpecificRectangle:
public Rectangle, // maybe this should be virtual as well, in case the hierarchy is extended later
public SpecificArea<T> // no virtual inheritance needed here
{
// specific implementation of Rectangle for type T
};