友元类
友元类所有的方法都可以访问原始类的私有成员和保护成员
声明
friend class ClassName
友元声明可以位于公有、私有或保护部分，其所在的位置无关紧要。由于Remote类提到了Tv类，
所以编译器必须了解Tv类后才能处理Remote类，为些最简单的方法是首先定义Tv类。也可以使用前向声明，稍后介绍
#include<iostream>
using std::cout;
using std::cin;
using std::endl;
class Tv
{
private:
int mode;
int volume;
public:
friend class Remote;
Tv(){};
void Show()
{
cout<<"welcome Tv "<<mode<<endl;
}
void set_mode(int i){
mode=i;
cout<<" mode = "<<mode<<endl;
};
};
class Remote
{
private:
int mode;
public:
void volup(Tv &t,int i)
{
t.volume=i;
cout<<" current volume "<<t.volume<<endl;
};
void ShowTv(Tv &t)
{
t.Show();
}
};
int main()
{
Tv _t;
_t.set_mode(3);
Remote _r;
_r.volup(_t,2);
_r.ShowTv(_t);
cin.get();
}上边的例子中代码真正访问Tv成员的是Remote方法是volup，其它的方法不是真需要作为友元的。因此它是唯一需要作为友元的方法
确实可以选择仅让特定的类成员成为另一个类的友元，需不必须让整个类成为友元，但这样稍微有点麻烦，必须小心排列各种声明和定义的顺序。
让Remote::volup()成为Tv类的友元的方法，在Tv类声明中将其声明为友元
class
{
friend void Remote::set_chan(Tv & t,int c);
};
然而，要使编译器能够处理这条语句，它必须知道Remote的定义，否则就无法知道Remote是一个类，而set_chan是这个类的方法。
这意味着就将Remote的定义放到Tv的定义前面。Remote的方法提到了Tv对象，而这意味着Tv定义应当位于Remote定义之前。避开这种循环
依赖的方法是，使用前向声明(forward declaration)为此，需要在Remote定义的前面插入下面的语句：
class Tv
这样排列次序应如下：
class Tv;
class Remote{...};
class Tv {....};
还有一个麻烦。程序清单Remote声明包含了内联代码，例如：
void volup(Tv &t,int i) { t.volume=i; cout<<" current volume "<<t.volume<<endl; };
由于这将调用Tv的一个方法，所以编译器此时必须已经看到了Tv类的声明，这样才能知道Tv有哪些方法，但正如看到的，该声明位于Remote声明方法后
。这种问题的解决方法是，使用Remote声明中只包含方法声明，并将实际的定义放在Tv类之后。这样
Remote方法的原型与下面类似：
void volup(Tv &t,int i);
检查该原型时，所有的编译器都需要知道Tv是一个类，而前向声明提供了这样的信息。当编译器到达真正的方法定义时，它已经读取了Tv类的声明，
并拥有了编译这些方法所需的信息。能过在方法定义中使用inline关键字，仍然可以使其成为内联方法。
#include<iostream>
using std::cout;
using std::cin;
using std::endl;
class Tv;
class Remote
{
private:
int mode;
public:
void volup(Tv &t,int i);
void ShowTv(Tv &t);
};
class Tv
{
private:
int mode;
int volume;
public:
friend void Remote::volup(Tv & t,int c);
Tv(){};
void Show()
{
cout<<"welcome Tv "<<mode<<endl;
}
void set_mode(int i){
mode=i;
cout<<" mode = "<<mode<<endl;
};
};
inline void Remote::volup(Tv & t,int i)
{
t.volume=i;
cout<<" current volume "<<t.volume<<endl;
};
inline void Remote::ShowTv(Tv & t)
{
t.Show();
};
int main()
{
Tv _t;
_t.set_mode(3);
Remote _r;
_r.volup(_t,2);
_r.ShowTv(_t);
cin.get();
}内联函数的链接性是内部的，这意味着函数定义必须在使用函数的文件中，这个例子中内联定义位于头文件中，因此在使用函数的文件中包含
头文件可确保将定义放在正确的地方。这可以将定义放在实现文件中，但必须删除关键字inline这样函数的链接性将是外部的
再看一个操作符重载的小例子
#include<iostream>
class B
{
public :
B()
{
myValue=2;
std::cout<<"B init"<<std::endl;
}
~B()
{
std::cout<<"B end"<<std::endl;
}
//这样做可以
/*B operator+(const B av)
{
B a;
a.myValue=myValue+av.myValue;
return a;
}*/
//也可以这么做
friend B operator+(const B b1,const B b2);
//------------------------------------------------
int GetMyValue()
{
return myValue;
}
//重载<<
friend std::ostream& operator<<(std::ostream& os,B);
private :
int myValue;
};
B operator+(const B b1,const B b2)
{
B a;
a.myValue=b1.myValue+b2.myValue;
return a;
}
std::ostream& operator<<(std::ostream& os,B b)
{
return os<<"重载实现："<<b.myValue<<std::endl;
}
int main()
{
B b1;
std::cout<<b1;
B b2;
B b3=b1+b2;
std::cout<<b3<<std::endl;
std::cin.get();
return 0;
}腾讯云开发者
