模板类与继承 

  1 #include <iostream>
  2 //1.模板类继承普通类
  3 
  4 class A
  5 {
  6 public:
  7     int m_a;
  8     A(int a) :m_a(a)
  9     {
 10         std::cout << "普通类A的构造函数" << std::endl;
 11     }
 12 };
 13 
 14 template<class T>
 15 class B:public A //这里模板类继承普通类A  因为普通类A没有定义默认无参构造函数 ,所以这里只要把基类的构造函数参数传递好就行了
 16 {
 17 public:
 18     T m_b;
 19     B(T b,int a):A(a),m_b(b)//传递参数a给基类构造函数
 20     {
 21         std::cout << "模板类B的构造函数" << std::endl;
 22     }
 23 };
 24 //-----------------------------------------------------------------------
 25 #include <iostream>
 26 
 27 //4.模板类继承模板类
 28 
 29 template<class TB>
 30 class B
 31 {
 32 public:
 33     TB m_b;
 34     B(TB b):m_b(b)//传递参数a给基类构造函数
 35     {
 36         std::cout << "模板类B的构造函数->" <<m_b<< std::endl;
 37     }
 38 };
 39 
 40 //原模板类 A 的模板类型为template<class TA> 要继承模板类B 只需将类B的模模参数添加上 再将类B的构造函数参数传递好就行了.
 41 template<class TA, class TB>
 42 class A:public B<TB>
 43 {
 44 public:
 45     TA m_a;
 46     A(TA a,TB b) :B<TB>(b),m_a(a)  //注意这里调用基类构造函数时  类B为模板类 所以他的实际类型为B<T> 
 47     {
 48         std::cout << "普通类A的构造函数->" << m_a << std::endl;
 49     }
 50 };
 51 
 52 
 53 
 54 int main()
 55 {
 56     A<int,std::string> a(10, "我是模板类的参数"); //这里创建对像时 一定要将自身的模板类型和基类的模板类型 显示定义
 57     return 0;
 58 }
 59 
 60 
 61 int main()
 62 {
 63     B<int> b(10,1);
 64     return 0;
 65 }
 66 //----------------------------------------------------------------
 67 #include <iostream>
 68 
 69 //2.普通类继承模板类的具体化版本
 70 
 71 template<class T>
 72 class B
 73 {
 74 public:
 75     T m_b;
 76     B(T b):m_b(b)//传递参数a给基类构造函数
 77     {
 78         std::cout << "模板类B的构造函数" <<m_b<< std::endl;
 79     }
 80 };
 81 
 82 class A:public B<int>
 83 {
 84 public:
 85     int m_a;
 86     A(int a,int b) :B(b),m_a(a)
 87     {
 88         std::cout << "普通类A的构造函数" << m_a << std::endl;
 89     }
 90 };
 91 
 92 
 93 
 94 int main()
 95 {
 96     A a(10, 1);
 97     return 0;
 98 }
 99 
100 //-----------------------------------------------------------------------
101 #include <iostream>
102 
103 //3.普通类继承模板类的完全模板化版本
104 
105 template<class T>
106 class B
107 {
108 public:
109     T m_b;
110     B(T b):m_b(b)//传递参数a给基类构造函数
111     {
112         std::cout << "模板类B的构造函数->" <<m_b<< std::endl;
113     }
114 };
115 
116 //这里因为普通类要继承模版类模板化  就要先定义一个基类一样的类模板
117 template<class T>
118 class A:public B<T>
119 {
120 public:
121     int m_a;
122     A(int a,T b) :B<T>(b),m_a(a)  //注意这里调用基类构造函数时  类B为模板类 所以他的实际类型为B<T> 
123     {
124         std::cout << "普通类A的构造函数->" << m_a << std::endl;
125     }
126 };
127 
128 
129 
130 int main()
131 {
132     A a(10, "我是模板类的参数");
133     return 0;
134 }
135 
136 //-----------------------------------------------------------------------
137 #include <iostream>
138 
139 //5.模板类继承模板参数给出的基类
140 
141 class A
142 {
143 public:
144     int m_a;
145     A(int a) :m_a(a)
146     {
147         std::cout << "普通类A的构造函数->" << m_a << std::endl;
148     }
149 };
150 
151 template <class TB>
152 class B
153 {
154 public:
155     TB m_b;
156     B(TB b) :m_b(b)
157     {
158         std::cout << "模板类B的构造函数->" << m_b << std::endl;
159     }
160 };
161 
162 template <class T>
163 class C :public T //注意 这里 基类 用模板定义
164 {
165 public:
166     int m_c;
167     C(int c):T(c),m_c(c) //这里用模板T 来调用基类构造函数
168     {
169         std::cout << "类C的构造函数->" << m_c << std::endl;
170     }
171 };
172 
173 template <class TD,class T,class TT>
174 class D :public T //注意 这里 基类 用模板定义 自身又是一个模板类 
175 {
176 public:
177     TD m_d;
178     D(TD d,TT tt) :T(tt), m_d(d) //这里用模板T 来调用基类构造函数
179     {
180         std::cout << "模板类D的构造函数->" << m_d << std::endl;
181     }
182 };
183 
184 
185 
186 
187 int main()
188 {
189     C<A> e1(1);
190     C<B<char>> e2(48);
191     D<int,B<std::string>,std::string> d1(1,"我是一个字符串");
192     return 0;
193 }

 

posted on 2026-01-27 11:40  海的寂寞  阅读(1)  评论(0)    收藏  举报

导航