1.三种友元函数
-非模板友元函数
-约束模板友元函数
-非约束模板友元函数
2.非类型参数
3.模板特化
1.三种友元函数
=====三种友元函数=====
--1---非模板友元函数
#include<iostream>
using namespace std;
template<typename T>
class R
{
T lin_number;
static int count;
public:
R(const T& t) :lin_number(t){ count++; }
~R(){count--;}
friend void fun();//友元函数1
friend void show(const R<T>& a);//友元函数2
};
template<typename T>
//初始化count
int R<T>::count = 0;
//定义函数
void fun()
{
cout<< "int_count:" << R<int>::count << endl;
cout<< "double_count:" << R<double>::count <<endl;
}
void show(const R<int>& a)
{
cout<< "int_lin:" << a.lin_number <<endl;
}
void show(const R<double>& a)
{
cout<< "double_lin:" <<a.lin_number <<endl;
}
int main()
{
//调用函数1
fun();
//创建函数对象
R<int> a(20);
fun();
R<double> b(50.2020);
fun();
show(a);
show(b);
return 0;
}
---2--约束模板友元函数
#include<iostream>
using namespace std;
//函数模板声名
template<typename T>
void fun();
template<typename T>
void show(T& a);
//类模板定义
template<typename U>
class R
{
U lin_number;
static int count;
public:
R(const U& u) :lin_number(u){ count++; }
~R(){count--;}
friend void fun<U>();//友元函数1
friend void show<>(R<U>& a);//友元函数2
};
template<typename T>
int R<T>::count = 0;//初始化count
template<typename T>
void fun()
{
cout<< "tl_size:" << sizeof(R<T>) <<endl;
cout<< "tl_count:" << R<T>::count <<endl;
}
template<typename T>
void show(T& t)
{
cout<< "TL-lin_number:" << t.lin_number <<endl;
}
int main()
{
//调用int类型函数模板实例
fun<int>();
//创建函数对象 class R中对函数进行了限制（限制为U型）个人感觉约束之意就在此呀
R<int>a(10);
R<int>b(20);
R<double>c(5.2);
//调用show()输出类的数据成员信息
show(a);
show(b);
show(c);
fun<int>();
fun<double>();
return 0;
}
--3---非约束模板友元函数
#include<iostream>
using namespace std;
template<typename T>
class F
{
private:
T lin_number;
public:
F(const T& t):lin_number(t){};
//类内部声名函数模板
template<typename U,typename V>
friend void show(U& u,V& v);
};
template<typename U,typename V>
void show(U& u,V& v)
{
cout<< u.lin_number<< "==AND=="<< v.lin_number<<endl;
}
int main()
{
F<int>a(10);
F<int>b(20);
F<double>c(5.2);
show(a,b);
show(a,c);
return 0;
}
2.非类型参数
==非类型参数==
#include<iostream>
using namespace std;
template<typename T,unsigned size>
class Array
{
T arr[size];
public:
T& operator[] (unsigned i) //运算符重载
{
if (i >= size)
cout<<"Out of the bound !" <<endl;
else
return arr[i];
}
};
int main()
{
Array<char,6>arr01;//定义长度为6的char类型数组
Array<int,10>arr02;//定义长度为10的int类型数组
arr01[0] = 'A';
cout<< arr01[0] <<endl; //如果此处输入的 下标 > = 6 则输出 Out of the bound !
for(int j = 0;j < 10;j++)
{
arr02[j] = j;
}
for(int k = 0;k < 10;k++)
{
cout<< arr02[k] <<"_";
}
return 0;
}
3.模板特化
==模板特化==
#include<iostream>
#include<cstring>
using namespace std;
template<typename T>
//定义函数模板
bool is_equal(T m,T n)
{
return m == n;
}
//函数模板的特化
template<>
bool is_equal(char* t1,char* t2)
{
return strcmp(t1 , t2) == 0;
}
//类模板
template<typename T>
class Compare
{
public:
bool is_equal(T m,T n)
{
return m == n;
}
};
//类模板的特化
template<>
class Compare<char*>
{
public:
bool is_equal(char* t1,char* t2)
{
return strcmp(t1 , t2) == 0;
}
};
int main()
{
char str1 = 'jjf';
char str2 = 'zl';
cout<< "函数模板=AND=函数模板特化：" <<endl;
cout<< is_equal(1,3) <<endl;
cout<< is_equal(str1,str2) <<endl;
cout<< "类模板=AND=类模板特化：" <<endl;
Compare<int> c1;
Compare<char> c2;
cout<< c1.is_equal(1,1)<<endl;
cout<< c2.is_equal(str1,str2)<<endl;
return 0;
}