一、函数模板
1、定义
template
返回值类型 模板名 (形参表){
函数体
};
template <class>
T2 print(T1 arg1, T2 arg2)
{
cout<p>2、不通过参数实例化函数模板</p>
<pre class="brush:css;toolbar:false;">#include <iostream>
using namespace std;
template <class>
T Inc(T n){
return 1 + n;
}
int main(){
cout (4)/2; //输出 2.5
return 0;
}</class></iostream>
3、函数模板可以重载，只要它们的形参表或类型参数表不同即可
template<class>
void print(T1 arg1, T2 arg2) {
cout
void print(T arg1, T arg2) {
cout
void print(T arg1, T arg2) {
cout<p>4、函数模板和函数的次序</p>
<p> 在有多个函数和函数模板名字相同的情况下，编译器如下处理一条函数调用语句</p>
<ul class=" list-paddingleft-2">
<li><p>先找参数完全匹配的普通函数(非由模板实例化而得的函数)。</p></li>
<li><p>再找参数完全匹配的模板函数。</p></li>
<li><p>再找实参数经过自动类型转换后能够匹配的普通函数。</p></li>
<li><p>上面的都找不到，则报错。</p></li>
</ul>
<pre class="brush:css;toolbar:false;">template <class>
T Max( T a, T b) {
cout
T Max( T a, T2 b) {
cout <p>5、匹配模板函数时，不进行类型自动转换</p>
<pre class="brush:css;toolbar:false;">template<class>
T myFunction( T arg1, T arg2)
{ cout<h3>二、类模板</h3>
<p>1、定义</p>
<p> 在定义类的时候，加上一个/多个类型参数。在使用类模板时，指定类型参数应该如何替换成具体类型，编译器据此生成相应的模板类。</p>
<p><span style="color:#f33b45;"> template <class> //类型参数表<br> class 类模板名{<br> 成员函数和成员变量<br> };</class></span></p>
<p>（1）类模板里成员函数的写法：<br> template <class> //类型参数表<br> 返回值类型 类模板名::成员函数名（参数表）{<br> ……<br> }<br>（2）用类模板定义对象的写法：<br> 类模板名 对象名(构造函数实参表);</class></p>
<pre class="brush:css;toolbar:false;">// Pair类模板
template <class>
class Pair{
public:
T1 key; //关键字
T2 value; //值
Pair(T1 k,T2 v):key(k),value(v) { };
bool operator & p) const;
};
template<class>
bool Pair<t1>::operator & p) const{ //Pair的成员函数 operator student("Tom",19); //实例化出一个类 Pair<string>
cout <p>2、用类模板定义对象</p>
<ul class=" list-paddingleft-2">
<li><p>编译器由类模板生成类的过程叫类模板的实例化。由类模板实例化得到的类，叫模板类。</p><div class="aritcle_card flexRow artxards">
<div class="artcardd flexRow">
<a class="aritcle_card_img" rel="nofollow" href="/ai/3990" title="昇思MindSpore"><img
src="https://img.php.cn/upload/ai_manual/001/246/273/178599593750354.png" alt="昇思MindSpore" onerror="this.onerror='';this.src='/static/lhimages/moren/morentu.png'" ></a>
<div class="aritcle_card_info flexColumn">
<a rel="nofollow" href="/ai/3990" title="昇思MindSpore" class="overflowclass">昇思MindSpore</a>
<p class="overflowclass">昇思MindSpore是一款AI学习资源工具，华为开源的自研AI深度学习框架。</p>
</div>
<a rel="nofollow" href="/ai/3990" title="昇思MindSpore" class="aritcle_card_btn flexRow flexcenter"><b></b><span>下载</span>
</a>
</div>
</div></li>
<li><p>同一个类模板的两个模板类是不兼容的。</p></li>
</ul>
<p>3、函数模版作为类模板成员</p>
<pre class="brush:css;toolbar:false;">template <class>
class A{
public:
template<class>
void Func( T2 t) { cout <p>4、类模板与非类型参数：类模板的“”中可以出现非类型参数</p>
<pre class="brush:css;toolbar:false;">template <class>
class CArray{
T array[size];
public:
void Print(){
for( int i = 0;i a2;
CArray<int> a3; //a2和a3属于不同的类</int></class>
5、类模板与派生
（1）类模板从类模板派生
template <class> int main() {
class A { B<int> obj1;
T1 v1; T2 v2; C<int> obj2;
}; return 0;
template <class> }
class B:public A<t2> { class B<int>:
T1 v3; T2 v4; public A<double>{
}; int v3; double v4;
template <class> };
class C:public B<t> {
T v5;
};</t></class></double></int></t2></class></int></int></class>
（2）类模板从模板类派生
template <class>
class A {
T1 v1; T2 v2;
};
template <class>
class B:public A<int> {
T v;
};
int main() {
B<char> obj1; //自动生成两个模板类 ：A<int> 和 B<char>
return 0;
}</char></int></char></int></class></class>
（3）类模板从普通类派生
class A {
int v1;
};
template <class>
class B:public A { //所有从B实例化得到的类 ，都以A为基类
T v;
};
int main() {
B<char> obj1;
return 0;
}</char></class>
（4）普通类从模板类派生
template <class>
class A {
T v1;
int n;
};
class B:public A<int> {
double v;
};
int main() {
B obj1;
return 0;
}</int></class>
6、类模板与友员函数
（1）函数、类、类的成员函数作为类模板的友元
void Func1() { }
class A { };
class B{
public:
void Func() { }
};
template <class>
class Tmpl{
friend void Func1();
friend class A;
friend void B::Func();
}; //任何从Tmp1实例化来的类 ，都有以上三个友元</class>
（2）函数模板作为类模板的友元
#include <iostream>
#include <string>
using namespace std;
template <class>
class Pair{
private:
T1 key; //关键字
T2 value; //值
public:
Pair(T1 k,T2 v):key(k),value(v) { };
bool operator & p) const;
template <class>
friend ostream & operator & p);
};
template <class>
bool Pair<t1>::operator & p) const{ //"小"的意思就是关键字小
return key
ostream & operator & p){
o student("Tom",29);
Pair<int> obj(12,3.14);
cout
ostream & operator & p)
生成的函数，都是任意Pair摸板类的友元</int></t1></class></class></class></string></iostream>
（3）函数模板作为类的友元
#include <iostream>
using namespace std;
class A
{
int v;
public:
A(int n):v(n) { }
template <class>
friend void Print(const T & p);
};
template <class>
void Print(const T & p){
cout <p>（4）类模板作为类模板的友元</p>
<pre class="brush:css;toolbar:false;">template <class>
class B {
T v;
public:
B(T n):v(n) { }
template <class>
friend class A;
};
template <class>
class A {
public:
void Func( ) {
B<int> o(10);
cout <p>7、类模板与静态成员变量</p>
<p> 类模板中可以定义静态成员 ，那么从该类模板实例化得到的所有类 ，都包含同样的静态成员 。</p>
<pre class="brush:css;toolbar:false;">#include <iostream>
using namespace std;
template <class>
class A{
private:
static int count;
public:
A() { count ++; }
~A() { count -- ; };
A( A & ) { count ++ ; }
static void PrintCount() { cout int A<int>::count = 0;
template int A<double>::count = 0;
int main(){
A<int> ia;
A<double> da;
ia.PrintCount();
da.PrintCount();
return 0;
}
//输出：1 1</double></int></double></int></class></iostream>
相关推荐：
C++免费学习笔记（深入）：立即使用
在学习笔记中，你将探索 C++ 的入门与实战技巧！
