非模板友元
声明一个常规友元
template <class T>
class HasFriend
{
public:
friend void counts();
}
上边的声明使counts()函数成为模板所有实例化的友元
counts()函数不是通过对象调用的(它是友元，不是成员函数)，也没有对象参数，那么它如何访问HasFriend对象的呢
有很多种可能性。它可以访问全局对象;可以使用全局指针访问非全局对象;可以创建自己的对象;可以访问独立对象的模板类
的静态数据成员。
如果要为友元函数提供械板类参数，可以如下所示来进行友元声明。要提供模板类参数，必须指明基体化
template<typename T>
class HasFriend
{
friend void report(HasFriend<T> &);
}
report()本身并不是模板函数，而只是使用一个模板作参数。这意味着必须要使用的友元定义显式基体化：
void report(HasFriend<short> &){....}
void report(HasFriend<int> &){...};
也就是说report(HasFriend<int> &)将成为HasFriend<int>类的友元。
#include<iostream>
using std::cout;
using std::cin;
using std::endl;
template<typename TT>
class HasFriendT
{
private:
TT item;
static int ct;
public:
HasFriendT(const TT & i):item(i){ct++;};
~HasFriendT(){ct--;};
friend void counts();
friend void report(HasFriendT<TT> &);
};
template <typename T>
int HasFriendT<T>::ct = 0;
void counts()
{
cout<<"int count: "<<HasFriendT<int>::ct<<";";
cout<<"double count:"<<HasFriendT<double>::ct<<endl;
}
void report(HasFriendT<int> & hf)
{
cout<<hf.item<<endl;
}
void report(HasFriendT<double> & hf)
{
cout<<hf.item<<endl;
}
int main()
{
counts();
HasFriendT<int> hfi1(10);
counts();
HasFriendT<double> hfdb(10.5);
report(hfi1);
HasFriendT<int> hfi2(20);
report(hfi2);
report(hfdb);
counts();
cin.get();
}
//int count: 0;double count:0
//int count: 1;double count:0
//10
//20
//10.5
//int count: 2;double count:1
约束模板友元函数友元的类型取决于类被实例化时的类型
可以修改上边的示例，使友元函数本身成为模板。具体的说，为约束模板友元作准备，要使类的每一个基体
化都获得与友元匹配的基体化。这需要3部
1首先，在类定义的前面声明每个模板函数
template <typename T>void counts()
template <typename T> void report(T &);
2然后，在函数中再次将模板声明为友元。这些语句根据类模板参数的类型声明具体化：
template <typename TT>
class HasFriendT
{
friend void counts<TT>();
friend void report<>(HasFriendT<TT> &);
};
声明中的<>指出这是模板具体化。对于report(),<>可以为空，因为可以从函数参数推断出如下模板类型参数：
HasFriendT<TT>
然而也可以使用：
report<HasFriendT<TT>>(HasFriendT<TT> &)
但是counts()函数没有参数，因此必须使用模板参数语法（<TT>）来指明其基体化。还需要注意的是，
TT是HasFriendT类的参数类型。
同样，理解这些声明的最佳方式也是设想声明一个特定具体化的对象时，它们将变成什么样子。例如，
假设声明了这样一个对象
HasFriendT<int> squack;
编译器将用int替换TT，并生成下面的类定义
class HasFriendT<int>
{
friend void counts<int>();
friend void report<>(HasFriendT<int> &);
}
3第三个条件是为友元提供模板定义
看例子：
#include<iostream>
using std::cout;
using std::cin;
using std::endl;
template <typename T> void counts();
template <typename T> void report(T &);
template<typename TT>
class HasFriendT
{
private:
TT item;
static int ct;
public:
HasFriendT(const TT & i):item(i){ct++;};
~HasFriendT(){ct--;};
friend void counts<TT>();
friend void report<>(HasFriendT<TT> &);
};
template <typename T>
int HasFriendT<T>::ct = 0;
template<typename T>
void counts()
{
cout<<"template size: "<<sizeof(HasFriendT<T>)<<";";
cout<<"template counts():"<<HasFriendT<T>::ct<<endl;
}
template<typename T>
void report(T & hf)
{
cout<<hf.item<<endl;
}
int main()
{
counts<int>();
HasFriendT<int> hfi1(10);
HasFriendT<int> hfi2(20);
HasFriendT<double> hfdb(10.5);
report(hfi1);
report(hfi2);
report(hfdb);
cout<<"counts<int> output:\n";
counts<int>();
cout<<"counts<double>() output:\n";
counts<double>();
cin.get();
}
//template size: 4;template counts():0
//10
//20
//10.5
//counts<int> output:
//template size: 4;template counts():2
//counts<double>() output:
//template size: 8;template counts():1
counts<double> 和couts<int> 报告的模板大小不同，这样每种T类型都有自己的友元函数count();
非约束模板友元
友元的所有具体化都是类的每一个具体化的友元
上边说的约束模板友元函数是在类外面声明的模板的具体化。int类型具体化获得int函数具体化，
依此类推。通过在类内部声明模板，可以创建非约束友元函数，即每个函数具体化都是每个类具体化的友元。
对于非约束友元，友元模板类型参数与模板类类型参数是不同的：
template <typename T>
{
template <typename C,typename D>
friend void Show2(C &,D &）
}
上边是一个使用非约束友元函数的例子，其中，函数调用show2(hfi1,hfi2)与下面的具体化匹配：
void Show2<ManyFriend<int> &,ManyFriend<int> &>(ManyFriend<int> & c,ManyFriend<int> & d);
因为它是所有ManyFriend 具体化的友元，所以能够访问所有具体化的item成员，但它只访问了ManyFriend<int>对象。
同样Show2(hfd,hfd2)与下面具体化匹配：
void Show2(ManyFirend<double> &,ManyFirend<int> &>(ManyFirend<double> & c,ManyFirend<int> & d);
它也是所有ManyFriend具体化的友元，并访问了ManyFirend<int> 对象的item成员和ManyFriend<double>对象的item成员
#include<iostream>
using std::count;
using std::cout;
using std::endl;
template<typename T>
class ManyFriend
{
private:
T item;
public:
ManyFriend(const T & i):item(i){};
template<typename C,typename D>
friend void Show2(C &,D &);
};
template<typename C,typename D>
void Show2(C & c,D & d)
{
cout<<c.item<<","<<d.item<<endl;
}
int main()
{
ManyFriend<int> hfi1(10);
ManyFriend<int> hfi2(20);
ManyFriend<double> hfdb(10.5);
cout<<"hfi1, hfi2";
Show2(hfi1,hfi2);
cout<<"hfdb,hfi2: ";
Show2(hfdb,hfi2);
std::cin.get();
}
//hfi1, hfi210,20
//hfdb,hfi2: 10.5,20
模板别名(c++ 11)
如果能为类型指定别名，将很方便，在模板设计中尤其如此，可使用typedef 为模板具体化指定别名：
typedef std::array<double,12> arrd;
type std::array<int,12> arri;
arrd gallons;//gallons 是 std::array<double,12> 类型
arrai days; //das 是std::array<int,12> 类型
c++11新增了使用模板提供一系列的别名，如下
template<typename T>
using arratype = std::array<T,12>;
这将arrtype定义为一个模板别名，可使用它来指定类型，如下所示：
arratype<double> gallons; // gallons是std::array<double,12>类型
arratype<int> days; //days 是 std::array<int ,12> 类型
总之，arrtype<T>表示类型 std::array<T,12>.
c++11 允许将语法using = 用于模板，用于非模板时，这种语法与常规typedef造价：
typedef const char * pc1;//用pc1为const char *的别名
using pc= const char * //用pc2为const char *的别名
typedef int (*pfunc)(int);//
//定义一个有10个指针的数组，该指针指向一个函数，该函数有一个整形参数，并返回一个整型？
//第一种方法：int (*a[10])(int);
//第二种方法：typedef int (*pfunc)(int);
//用法 pfunc a[10];
uisng pc1= const int *(*)[10]// int *(*)[10]
上边说的Remote方法可以影响Tv的对象，直接访问Tv的属性和方法。也可以通过让类彼此成为对方的友元来实现，
即除了Remote是Tv的友元外，Tv还是Remote的友元。需要记住的一点是，对于使用Remote对象的Tv方法，其原型
可在Remote类声明之前声明，但必须在Remote类声明之后定义，以便编译器有足够的信息来编译该方法。这种方案与
下面类似 ：
class Tv
{
friend class Remote;
public:
void buzz(Remote & r);
};
class Remote
{
friend class Tv;
public:
void Bool volup(Tv & t){t.volup();};
};
inline void Tv::buzz(Remote & r)
{
......
};
由于 Remote 的声明位于Tv声明后面，所以可以在类声明中定义Remote::volup(),但Tv::buzz()方法必须在Tv声明的外部定义，使
其位于Remote声明的后面。如果不希望buzz()是内联的，则应在一个单独的方法定义文件中定义它。
共同的友元：
一个成员函数，它可以是一个类的成员，同时是另一个类的友元，但有时将函数作为两个类的友元更合理。例如，假定有一具Probe类和一个
Analyzer类，前者表示某种可编程的测量设备，后者表示某种可编程的分析设备。这两个类都有内部时钟，且希望它们能够同步，则该包含下
述代码行：
class Analyzer;//前向声明
前向声明使编译器看到Probe类声明中的友元声明时，知道Analyzer是一种类型。
class Probe
{
friend void sync(Analyzer & a ,const Probe & p);
friend void sync(Probe & p,const Analyzer & a);
};
class Analyzer
{
friend void sync(Analyzer & a ,const Probe & p);
friend void sync(Probe & p,const Analyzer & a);
};
//定义这些友元函数