模板类与继承

//1.模板类继承普通类

class A
{
public:
int m_a;
A(int a) :m_a(a)
{
std::cout << "普通类A的构造函数" << std::endl;
}
};

template
class B:public A //这里模板类继承普通类A 因为普通类A没有定义默认无参构造函数 ,所以这里只要把基类的构造函数参数传递好就行了
{
public:
T m_b;
B(T b,int a):A(a),m_b(b)//传递参数a给基类构造函数
{
std::cout << "模板类B的构造函数" << std::endl;
}
};
//-----------------------------------------------------------------------

include

//4.模板类继承模板类

template
class B
{
public:
TB m_b;
B(TB b):m_b(b)//传递参数a给基类构造函数
{
std::cout << "模板类B的构造函数->" <<m_b<< std::endl;
}
};

//原模板类 A 的模板类型为template 要继承模板类B 只需将类B的模模参数添加上 再将类B的构造函数参数传递好就行了.
template<class TA, class TB>
class A:public B
{
public:
TA m_a;
A(TA a,TB b) :B(b),m_a(a) //注意这里调用基类构造函数时 类B为模板类 所以他的实际类型为B
{
std::cout << "普通类A的构造函数->" << m_a << std::endl;
}
};

int main()
{
A<int,std::string> a(10, "我是模板类的参数"); //这里创建对像时 一定要将自身的模板类型和基类的模板类型 显示定义
return 0;
}

int main()
{
B b(10,1);
return 0;
}
//----------------------------------------------------------------

include

//2.普通类继承模板类的具体化版本

template
class B
{
public:
T m_b;
B(T b):m_b(b)//传递参数a给基类构造函数
{
std::cout << "模板类B的构造函数" <<m_b<< std::endl;
}
};

class A:public B
{
public:
int m_a;
A(int a,int b) :B(b),m_a(a)
{
std::cout << "普通类A的构造函数" << m_a << std::endl;
}
};

int main()
{
A a(10, 1);
return 0;
}

//-----------------------------------------------------------------------

include

//3.普通类继承模板类的完全模板化版本

template
class B
{
public:
T m_b;
B(T b):m_b(b)//传递参数a给基类构造函数
{
std::cout << "模板类B的构造函数->" <<m_b<< std::endl;
}
};

//这里因为普通类要继承模版类模板化 就要先定义一个基类一样的类模板
template
class A:public B
{
public:
int m_a;
A(int a,T b) :B(b),m_a(a) //注意这里调用基类构造函数时 类B为模板类 所以他的实际类型为B
{
std::cout << "普通类A的构造函数->" << m_a << std::endl;
}
};

int main()
{
A a(10, "我是模板类的参数");
return 0;
}

//-----------------------------------------------------------------------

include

//5.模板类继承模板参数给出的基类

class A
{
public:
int m_a;
A(int a) :m_a(a)
{
std::cout << "普通类A的构造函数->" << m_a << std::endl;
}
};

template
class B
{
public:
TB m_b;
B(TB b) :m_b(b)
{
std::cout << "模板类B的构造函数->" << m_b << std::endl;
}
};

template
class C :public T //注意 这里 基类 用模板定义
{
public:
int m_c;
C(int c):T(c),m_c(c) //这里用模板T 来调用基类构造函数
{
std::cout << "类C的构造函数->" << m_c << std::endl;
}
};

template <class TD,class T,class TT>
class D :public T //注意 这里 基类 用模板定义 自身又是一个模板类
{
public:
TD m_d;
D(TD d,TT tt) :T(tt), m_d(d) //这里用模板T 来调用基类构造函数
{
std::cout << "模板类D的构造函数->" << m_d << std::endl;
}
};

int main()
{
C e1(1);
C<B> e2(48);
D<int,Bstd::string,std::string> d1(1,"我是一个字符串");
return 0;
}