Наследование из класса шаблона в С++

Ответ 1

Для понимания шаблонов это имеет огромное преимущество, чтобы получить терминологию прямо, потому что способ, которым вы говорите о них, определяет способ думать о них.

В частности, 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 к той же функции (которая сама не должна знать тип области). Поскольку классы 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
};

Ответ 2

Вы просто пытаетесь извлечь из Area<int>? В этом случае вы делаете это:

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

EDIT: после выяснения, похоже, вы на самом деле пытаетесь сделать Rectangle шаблон, и в этом случае должно работать следующее:

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

Ответ 3

class Rectangle : public Area<int> {
};

Ответ 4

Сделайте Rectangle шаблоном и передайте имя типа в Area:

template <typename T>
class Rectangle : public Area<T>
{

};

Ответ 5

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

Ответ 6

#include<iostream>

using namespace std;

template<class t> 
class base {
protected:
    t a;
public:
    base(t aa){
        a = aa;
        cout<<"base "<<a<<endl;
    }
};

template <class t> 
class derived: public base<t>{
    public:
        derived(t a): base<t>(a) {
        }
        //Here is the method in derived class 
    void sampleMethod() {
        cout<<"In sample Method"<<endl;
    }
};

int main() {
    derived<int> q(1);
    // calling the methods
    q.sampleMethod();
}