关于C++中的友元函数的总结++++++++++++==数据共享的另一种方式static

最新推荐文章于 2022-05-19 22:35:28 发布

lusic01

最新推荐文章于 2022-05-19 22:35:28 发布

阅读量787

点赞数

1.1为什么要使用友元函数

如果类A中的函数要访问类B中的成员（例如智能指针类的实现）

那么类A中该函数要是类B的友元函数

为了其他类的成员函数直接访问该类的私有变量：

即允许外面的类或函数去访问类的私有变量和保护变量，从而使两个类共享同一函数

实际上具体大概有下面两种情况需要使用友元函数

1）运算符重载的某些场合需要使用友元

2）两个类要共享数据的时候

1.2使用友元函数的优缺点

优点：提高效率

缺点：破坏了封装机制，尽量不使用成员函数，不得已才使用友元函数

2.1友元函数的参数：

因为友元函数没有this指针，则参数要有三种情况

2.1.1 要访问非static成员时，需要对象做参数；

2.1.2 要访问static成员或全局变量时，则不需要对象做参数；

2.1.3 如果做参数的对象是全局对象，则不需要对象做参数；

2.2友元函数的位置

因为友元函数是类外的函数，所以它的声明可以放在类的私有段或公有段且没有区别。

2.3友元函数的调用

可以直接调用友元函数，不需要通过对象或指针

2.4友元函数的分类：

根据这个函数的来源不同，可以分为三种方法：

2.4.1普通函数友元函数

声明： friend + 普通函数声明

实现位置：可以在类外或类中

实现代码：与普通函数相同

调用：类似普通函数，直接调用

class INTEGER

{

　　friend void Print(const INTEGER& obj);//声明友元函数

};

void Print(const INTEGER& obj）

{

　　 //函数体

}

void main()

{

　　INTEGER obj;

　　Print(obj);//直接调用

}

2.4.2类Y的所有成员函数都为类X友元函数—友元类

使用单个声明使Y类的所有函数成为类X的友元，它提供一种类之间合作的一种方式，使类Y的对象可以具有类X和类Y的功能。

声明位置：公有私有均可，常写为私有(把类看成一个变量)

声明： friend + 类名（不是对象哦）

class girl;

class boy

{

public:

　　void disp(girl &);

};

void boy::disp(girl &x) //函数disp()为类boy的成员函数，也是类girl的友元函数

{

　　cout<<"girl's name is:"<<x.name<<",age:"<<x.age<<endl;//借助友元，在boy的成员函数disp中，借助girl的对象，直接访问girl的私有变量

}

class girl

{

private：

　　char *name;

　　int age;

　　friend boy; //声明类boy是类girl的友元

};

2.4.3类Y的一个成员函数为类X的友元函数

使类Y的一个成员函数成为类X的友元，具体而言：在类Y的这个成员函数中，借助参数X，可以直接以X的私有变量

声明位置：声明在公有中（本身为函数）

声明：friend + 成员函数的声明

调用：先定义Y的对象y---使用y调用自己的成员函数---自己的成员函数中使用了友元机制

2.4.3.3代码：

实现代码和2.4.2.3中的实现及其相似只是设置友元的时候变为friend void boy::disp(girl &);自己解决喽……

小结：其实一些操作符的重载实现也是要在类外实现的，那么通常这样的话，声明为类的友元是必须滴。

4.友元函数和类的成员函数的区别

4.1 成员函数有this指针，而友元函数没有this指针。

4.2 友元函数是不能被继承的，就像父亲的朋友未必是儿子的朋友。

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

C++参考-------成员函数，友元函数和一般函数有区别

//例：使用成员函数、友元函数和一般函数的区别
#include <iostream>
using namespace std;
class Time
{
public:
    Time(int h,int m,int s):hour(h),minute(m),sec(s) {}
    void display1();    //display1是成员函数
    friend void display2(Time &); //display2是友元函数
    int getHour(){return hour;}
    int getMinute(){return minute;}
    int getSec(){return sec;}
private:
    int hour;
    int minute;
    int sec;
};
void Time::display1() //成员函数display1的实现，dispaly1前加Time::
{
    //以hour形式直接访问私有数据成员，实质是this->hour形式
    cout<<hour<<":"<<minute<<":"<<sec<<endl;
}
void display2(Time &t) //友元函数dispaly2的实现，不加Time::，友元并不是类的成员
{
    //虽然不是类的成员函数，却可以用t.hour的形式直接访问私有数据成员——这就是友元
    cout<<t.hour<<":"<<t.minute<<":"<<t.sec<<endl;
}
void display3(Time &t) //display3是一般函数，dispaly3前不加Time::
{
    //不能直接访问，只能用公共接口t.getHour()形式访问私有数据成员
    cout<<t.getHour()<<":"<<t.getMinute()<<":"<<t.getSec()<<endl;
}
int main()
{
    Time t1(10,13,56);
    t1.display1(); //成员函数这样调用：对象名.函数名()
    display2(t1);   //友员函数的调用和一般函数无异（但实现中可以不同）
    display3(t1);   //一般函数的调用
    return 0;
}

（2）模仿上面的示例，完成求点类中距离的任务。你需要实现求距离函数的三种版本：分别利用成员函数、友元函数和一般函数求两点间距离的函数，并设计main()函数完成测试。
提示：此项目和例子的区别在于“距离是一个点和另外一个点的距离”，不同版本在参数上有体现。三个版本建议分开测试，也可以如示例，放在一个程序中完成。
下面是点类的部分代码。

class CPoint
{
private:
    double x;  // 横坐标
    double y;  // 纵坐标
public:
    CPoint(double xx=0,double yy=0):x(xx),y(yy){}
    ……//请继续写需要的代码
};

+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++#include<iostream>
#include<Cmath>
using namespace std;
class CPoint
{
private:
    double x; // 横坐标
    double y; // 纵坐标
public:
    CPoint(double xx=0,double yy=0):x(xx),y(yy) {}
    double distance1(CPoint &); //参数用const CPoint &更佳
    friend double distance2(CPoint &, CPoint &) ;
    double getX()
    {
        return x;
    }
    double getY()
    {
        return y;
    }
};

double distance3(CPoint &,CPoint &) ;

double CPoint::distance1(CPoint &p)
{
    double dx=(x-p.x), dy=y-p.y;
    return sqrt(dx*dx+dy*dy);
}

double distance2(CPoint &p1,CPoint &p2)
{
    double dx=(p1.x-p2.x), dy=p1.y-p2.y;
    return sqrt(dx*dx+dy*dy);
}

double distance3(CPoint &p1,CPoint &p2)
{
    double dx=(p1.getX()-p2.getX()), dy=p1.getY()-p2.getY();
    return sqrt(dx*dx+dy*dy);
}

int main()
{
    CPoint p1(10,13), p2(-5,6);
    cout<<"1. "<<p1.distance1(p2)<<endl;
    cout<<"2. "<<distance2(p1,p2)<<endl;
    cout<<"3. "<<distance3(p1,p2)<<endl;
    return 0;
}

常见问题：下面是某同学的解答

#include<iostream>
#include<Cmath>
using namespace std;
class CPoint
{
private:
    double x;
    double y;
public:
    CPoint(double xx=0,double yy=0):x(xx),y(yy){}
    friend void distance(CPoint &,CPoint &);
};
void distance(CPoint &p1,CPoint &p2)
{
    double l;
    l=sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
    cout<<l;
}
int main()
{
    CPoint t1(1,2),t2(2,3);
    distance(t1,t2); //SBSBSBSBSBSBSBSBSBSBSBSBSBSB
    return 0;
}

看吧，错误延伸到了系统提供的文件中

莫慌张，说的是distance

实际上，自己的程序中22行调用的distance(t1,t2);和命名空间中已经定义的distance冲突了。C++变得庞大，并且

也是奔着做大工程的，这种事情常见，也是使用C++中必须庞大，并且也是奔着做大工程的，这种事情常见，也是

使用C++中必须解决的，且C++已经有很好的解决方案了

下面是两种应对的技巧：

1）惹不起，咱躲得起——人家已经定义distance了，咱换个名，不就行了吗？

#include<iostream>
#include<Cmath>
using namespace std;
class CPoint
{
private:
    double x;
    double y;
public:
    CPoint(double xx=0,double yy=0):x(xx),y(yy){}
    friend void dist(CPoint &,CPoint &);   //改个名字避免了冲突
};
void dist(CPoint &p1,CPoint &p2)
{
    double l;
    l=sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
    cout<<l;
}
int main()
{
    CPoint t1(1,2),t2(2,3);
    dist(t1,t2);
    return 0;
}

（二）我行我素——你有你的，我有我的，在我的地盘，就用我的！

背景：回顾域运算符（::），可以限定符号所处的域，如std::cout，说cout是std命名空间中的，再如Time::add_sec(1)，说add_sec是Time类的成员。当域运算符（::）前面什么也不加时，能起到屏蔽作用。如下面的程序，main中调用的::distance(...)，意思是，不管其他地方有没有distance，这儿用的就我自己的

#include<iostream>
#include<Cmath>
using namespace std;
class CPoint
{
private:
    double x;
    double y;
public:
    CPoint(double xx=0,double yy=0):x(xx),y(yy){}
    friend void distance(CPoint &,CPoint &);
};
void distance(CPoint &p1,CPoint &p2)
{
    double l;
    l=sqrt((p1.x-p2.x)*(p1.x-p2.x)+(p1.y-p2.y)*(p1.y-p2.y));
    cout<<l;
}
int main()
{
    CPoint t1(1,2),t2(2,3);
    ::distance(t1,t2);   //调用时，前面加上 ::
    return 0;
}