一般来说,类的私有成员只能在类的内部访问,类外的函数是不能访问它们的。
但是,可以将一个函数定义为类的友元函数,这时该函数就可以访问该类的私有成员了。
同时,也可以把另一个类B定义为本类A的友元类,这样B类就可以访问A类的任何成员了
***************函数传参存在隐士转换,形参必须声明const才能真正绑定
1)当函数的形参类型是const类型时,可以通过const类型的实参调用函数,也可以用非const类型的实参调用函数。
2)当函数的形参类型是非const类型时,只能用非const类型的实参调用函数。
综上两点可以看出,在不需要修改实参的情况下,函数的形参类型声明为const类型时,初始化的限制条件会相对放松些。所以有一种情况应当引起重视,就是应该吧不需要修改的引用形参定义为const引用。因为普通的非const引用会限制函数的应用,比如,这样的形参不能用const对象初始化,不能用字面值或产生右值的表达式初始化。
|
友元之非成员函数:
在类的定义中用friend声明了一个外部函数或其他类的成员函数(public和private均可)后,这个外部函数称为类的友元函数。
友元函数声明的基本格式为:
friend 函数原型;
友元函数中可访问类的private成员
将类比作一个家庭,类的private成员相当于家庭的秘密,一般的外人是不允许探听这些秘密的,只有friend(朋友)才有能力探听这些秘密。
#include <iostream>
#include<math.h>
using namespace std;
class point
{
private:
int _x;
int _y;
public:
point(int x=0,int y=0):_x(x),_y(y)
{
cout<<"point(int,int)"<<endl;
}
void print()
{
cout<<"("<<_x<<","<<_y<<")"<<endl;
}
friend float dis(const point & a1,const point & a2);
};
|
float dis(const point& a1,const point& a2)
{
return sqrt((a1._x-a2._x)*(a1._x-a2._x)+
(a1._y-a2._y)*(a1._y-a2._y));
}
int main()
{
point a1(1,2);
point a2(4,6);
cout<<"dis="<<dis(a1,a2)<<endl;
return 0;
}
![]() |
友元之成员函数:
A类的成员函数
(公有)作为B类的友元函数时,必须先定义A类,而不仅仅是声明它。
注意
:
将其他类的成员函数申明为本类的友元函数后,该友元函数并不能变成本类的成员函数。也就是说,朋友并不能变成家人。
#include<iostream>
#include<math.h>
using namespace std;
class point; //前向声明
class line
{
public:
float distance(const point &,const point &); //类line的成员作为point类的友元函数
//必须先定义line类,而不仅仅是声明;
#if 0
{
return sqrt(
(p2._x-p1._x)*(p2._x-p1._x) +
(p2._y-p1._y)*(p2._y-p1._y)
); //_x和_y在这里未知
}
#endif
};
class point
{
public:
point(int x=0,int y=0):_x(x),_y(y)
{
cout<<"point(int,int)"<<endl;
}
~point()
{
cout<<"~point()"<<endl;
}
void print()
{
cout<<"("<<_x<<","<<_y<<")"<<endl;
}
friend float line::distance(const point &,const point &); //实现必须要放到point类外面,因为里面用到了point
#if 0
{//类point还没有定义完,这里point未知
return sqrt(
(p2._x-p1._x)*(p2._x-p1._x) +
(p2._y-p1._y)*(p2._y-p1._y)
); //_x和_y在这里未知
}
#endif
private:
int _x;
int _y;
};
|
#if 1
float line::distance(const point &p1,const point &p2)
{
return sqrt(
(p2._x-p1._x)*(p2._x-p1._x) +
(p2._y-p1._y)*(p2._y-p1._y)
);
}
#endif
int main()
{
point p1(1,2);
point p2(3,4);
line tmp;
cout<<tmp.distance(p2,p1)<<endl;
return 0;
}
//point(int,int)
//point(int,int)
//2.82843
//~point()
//~point()
|
Line类的成员函数dis(…)的实现必须在类外进行,且必须在Point类的定义之后。因为其参数中包含了Point这种类型。
Line类的dis()函数本来是不能访问Point.x和Pint.y这种Point类的private成员的,但在Point类中将dis()申明为友元函数后就能访问了。但dis()函数依然不是Point类的成员函数。也就是说,dis() 是Point类的朋友了,可以访问Point类的私有成员变量x和y了。
|
友元函数的重载:
要想使得一组重载函数全部成为类的友元,必须一一声明,否则只有匹配的那个函数会成为类的友元,编译器仍将其他的当成普通函数来处理。
class Exp
{
public:
firend void test(int);
};
void test();
void test(int);
void test(double);
|
友元类:
类A作为类B的友元时,类A称为友元类。A中的所有成员函数都是B的友元函数,都可以访问B中的所有成员。
A可以在B的public部分或private部分进行声明,方法如下:
friend [class]<类名>; //友元类类名
#include <iostream>
#include<math.h>
using namespace std;
class point; //前向声明
class line
{
public:
//让类的每一个成员函数都成为point类的友元函数
float dis(const point &a1,const point &a2);
void set(point &p1,int x,int y);
};
class point
{
private:
int _x;
int _y;
public:
point(int x=0,int y=0):_x(x),_y(y)
{
cout<<"point(int,int)"<<endl;
}
void print()
{
cout<<"("<<_x<<","<<_y<<")"<<endl;
}
//友元类
friend class line;
//friend line; 也可以
};
|
float line::dis(const point &a1,const point &a2)
{
return sqrt((a1._x-a2._x)*(a1._x-a2._x)+
(a1._y-a2._y)*(a1._y-a2._y));
}
void line::set(point &p1,int x,int y)
{
p1._x=x;
p1._y=y;
}
int main()
{
point a1(1,2);
point a2(4,6);
cout<<"a1 ";
a1.print();
line aa;
cout<<"dis="<<aa.dis(a1,a2)<<endl;
cout<<"重新设置a1的值:"<<endl;
aa.set(a1,3,4);
cout<<"a1 ";
a1.print();
return 0;
}
![]() |
友元是否破坏了封装性:
不可否认,友元在一定程度上将类的私有成员暴露出来,
破坏了信息隐藏机制,似乎是种“副作用很大的药”,但俗话说“良药苦口”,好工具总是要付出点代价的,拿把锋利的刀砍瓜切菜,总是要注意不要割到手指的。
但是友元的存在,使得类的接口扩展更为灵活,使用
友元进行运算符重载从概念上也更容易理解一些,而且,C++规则已经极力地将友元的使用限制在了一定范围内,
它是单向的、不具备传递性、不能被继承,所以,
应尽力合理使用友元。