Heredar de una clase de plantilla en c++

Para entender las plantillas, es una gran ventaja obtener la terminología correcta porque la forma en que hablas de ellas determina la forma de pensar sobre ellas.

Específicamente, Area no es una clase de plantilla, sino una plantilla de clase. Es decir, es una plantilla a partir de la cual se pueden generar clases. Area<int>es tal clase (es no un objeto, pero por supuesto puede crear un objeto de esa clase de la misma manera que puede crear objetos de cualquier otra clase). Otro la clase sería Area<char>. Tenga en cuenta que son clases completamente diferentes, que no tienen nada en común, excepto por el hecho de que se generaron a partir de la misma plantilla de clase.

Puesto que Area no es una clase, no se puede derivar la clase Rectangle de ella. Solo puede derivar una clase de otra clase (o varias de ellas). Dado que Area<int> es una clase, podrías, por ejemplo, derivar Rectangle de ella:

class Rectangle:
  public Area<int>
{
  // ...
};

Dado que Area<int> y Area<char> son clases diferentes, incluso puede derivar de ambas en al mismo tiempo (sin embargo, al acceder a los miembros de ellos, tendrá que lidiar con ambigüedades):

class Rectangle:
  public Area<int>,
  public Area<char>
{
  // ...
};

Sin embargo, debe especificar de qué clase derivar cuando defina Rectangle. Esto es cierto sin importar si esas clases se generan a partir de una plantilla o no. Dos objetos de la misma clase simplemente no pueden tener diferentes jerarquías de herencia.

Lo que puedes hacer es hacer Rectangle una plantilla también. Si escribes

template<typename T> class Rectangle:
  public Area<T>
{
  // ...
};

Tiene una plantilla Rectangle de la que puedes obtener una clase Rectangle<int> que deriva de Area<int>, y una clase diferente Rectangle<char> que deriva de Area<char>.

Puede ser que desee tener un solo tipo Rectangle para que pueda pasar todo tipo de Rectangle a la misma función (que en sí misma no necesita saber el tipo de Área). Dado que las clases Rectangle<T> generadas al instanciar la plantilla Rectangle son formalmente independientes entre sí, no funciona de esa manera. Sin embargo, puede hacer uso de la herencia múltiple aquí:

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);
}

Si es importante que tu genérico Rectangle se derive de un genérico Area también puedes hacer el mismo truco con 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
};