C++友元函数及友元类全总结

合集下载

友元函数友元类及用法

友元函数友元类及用法

友元函数友元类及⽤法友元函数可以修改访问类内部的私有成员,友元函数的参数之⼀是类元素,类指针或者是类引⽤,意思是修改某个对象中的类私有成员(对象⼀般是访问不了类私有成员的).若F类是A类的友元类,那么F类的所有成员函数都是A类的友元函数,在F类⾥声明⼀个A类的对象a,在F类内部,这个对象a可以直接访问A类的私有成员.友员类通常设计为⼀种对数据操作或类之间传递消息的辅助类#include "iostream"using namespace std;class A1{public:A1(){a1 = 100;a2 = 200;}int getA1(){return this->a1;}//声明⼀个友元函数friend void setA1(A1 *p, int a1); //什么这个函数是这个类的好朋友protected:private:int a1;int a2;};void setA1(A1 *p, int a1){p->a1 = a1;}//friend 破坏了类的封装性。

//friend关键字是⼀个关系户//why ⽆奈之际 java class//java---》1.class==》class==>java类//java类的反射 sun jdk api//cc++ 1预编译gcc -E 2汇编 gcc -i 3编译gcc -c 3、链接ld ===》汇编代码//friend//应⽤场景。

//const关键字冒牌货c//register//typedef 混号王void main11(){A1 mya1;cout<<mya1.getA1()<<endl;setA1(&mya1, 300);cout<<mya1.getA1()<<endl;system("pause");}class A{//b是a的好朋友friend class B;public:void display(){cout<<x<<endl;}protected:private:int x;};class B{public:void setA(int x){Aobj.x = x;}void printA(){cout<<Aobj.x<<endl; }protected:private:A Aobj;};void main(){B b1;b1.setA(100);b1.printA();system("pause");}。

友元函数及友元类

友元函数及友元类

友元函数及友元类已有 20621 次阅读 2009-5-9 15:43 |个人分类:C/C++什么是友元(friend)?允许另一个类或函数访问你的类的东西。

友元可以是函数或者是其他的类。

类授予它的友元特别的访问权。

通常同一个开发者会出于技术和非技术的原因,控制类的友元和成员函数(否则当你想更新你的类时,还要征得其它部分的拥有者的同意)。

分清成员函数,非成员函数和友元函数成员函数和非成员函数最大的区别在于成员函数可以是虚拟的而非成员函数不行。

所以,如果有个函数必须进行动态绑定,就要采用虚拟函数,而虚拟函数必定是某个类的成员函数。

关于这一点就这么简单。

如果函数不必是虚拟的,情况就稍微复杂一点。

Ø类的主要特点之一是数据隐藏,即类的私有成员只能在类定义的范围内使用,也就是说私有成员只能通过它的成员函数来访问。

Ø但是,有时候需要在类的外部访问类的私有成员。

为此,就需要寻找一种途径,在不放弃私有数据安全性的情况下,使得类外部的函数或类能够访问类中的私有成员,在C++中就用友元作为实现这个要求的辅助手段。

ØC++中的友元为数据隐藏这堵不透明的墙开了一个小孔,外界可通过这个小孔窥视类内部的秘密,友元是一扇通向私有成员的后门。

Ø友元可分为:友元函数,友元成员,友元类。

Ø友元函数不是当前类的成员函数,而是独立于当前类的外部函数,但它可以访问该类的所有对象的成员,包括私有成员和公有成员。

Ø在类定义中声明友元函数时,需在其函数名前加上关键字friend。

此声明可以放在公有部分,也可以放在私有部分。

友元函数可以定义在类的内部,也可以定义在类的外部。

1.友元函数虽然可以访问类对象的私有成员,但它毕竟不是成员函数。

因此,在类的外部定义友元函数时,不必像成员函数那样,在函数名前加上“类名::”。

2.友元函数一般带有一个该类的入口参数。

因为友元函数不是类的成员,所以它不能直接引用对象成员的名称,也不能通过this指针引用对象的成员,它必须通过作为入口参数传递进来的对象名或对象指针来引用该对象的成员。

友元函数和友元类

友元函数和友元类

友元函数和友元类⼀个类中可以有 public、protected、private 三种属性的成员,通过对象可以访问 public 成员,只有本类中的函数可以访问本类的 private 成员。

在类的外部就没有办法访问类的private成员吗?不是的。

现在,我们来介绍⼀种例外情况——友元(friend)。

借助友元(friend),可以使得其他类中的成员函数以及全局范围内的函数访问当前类的 private 成员。

1、友元函数在当前类以外定义的、不属于当前类的函数也可以在类中声明,但要在前⾯加 friend 关键字,这样的函数称为友元函数。

友元函数可以是不属于任何类的⾮成员函数,也可以是其他类的成员函数。

友元函数可以访问当前类中的所有成员,包括public、protected和private属性的成员。

所以,可以说友元函数破坏了类的封装性。

定义⽅式:class A{private:int i;friend void FriendFun(A *ptr,int x);public:void MemberFun(int x);};...void FriendFun(A *ptr, int x){ptr->i = x;}void A::MemberFun(int x){i = x;}说明:1)友元函数在类中的位置与访问权限⽆关,即“friend void FriendFun(A *ptr,int x);”语句放在private或者public都没有影响;2)友元函数通过对象参数访问私有成员,即需要输⼊参数中需要有对象的指针。

下⾯看⼀个简单例⼦:#include <iostream>using namespace std;class TestFriend{public:TestFriend(int a,int b){this->a = a;this->b = b;}int get_a(){return this->a;}friend void modifyTest(TestFriend *pT,int a);private:int a;int b;};void modifyTest(TestFriend *pT,int a){pT->a = a;}int main() {TestFriend tf(1,2);cout << tf.get_a() << endl;modifyTest(&tf,4);cout << tf.get_a() << endl;return0;}modifyTest()是⼀个全局范围内的函数,它不属于任何类,它的作⽤是修改对象pT中的a值,在类TestFriend中a为私有成员,原则上不能通过对象访问,但是加⼊友元之后便可以访问。

C.C++友元函数&友元类

C.C++友元函数&友元类

友元TAG:面向对象程序设计,面向对象的语言实现C++,友元TEXT:有时两个类或一个函数与某个类之间的关系十分密切,为了程序运行效率着想,希望这个函数和类可以像另一个类的成员一样无限制地存取它的所有成员,同时还希望在形式上尽量保持类的独立性和封装性。

为了解决这类问题,C++提供了友元的概念,一个类的友元可以存取这个类的所有成员,包括私有成员。

友元一般分为两种一一友元函数和友元类。

REF:.txt,友元函数.txt,友元类.txt友元函数TAG:面向对象程序设计,面向对象的语言实现C++,友元,友元函数TEXT:在类中可以将另一个函数声明为这个类的友元,这时,虽然这个函数可能是位于另一个文件中的外部函数或属于另一个类的成员函数,但它却具有了访问本类所有成员的权限,如同是本类的一个成员一样。

说明友元函数的方法如下。

[例2] 友元函数的说明示例。

#include "iostream.h"#include "math.h"class CPoint{private:double m_x;double m_y;public:CPoint(double x,double y){m_x=x;m_y=y;}double GetX(){ return m_x;}double GetY(){ return m_y; }friend double GetDistance(CPoint&a, CPoint&b);};double GetDistance(CPoint &a,CPoint &b){double x_increament=a.m_x- b.m_x;double y_increament=a.m_y- b.m_y;return sqrt(x_increament*x_increament+y_increament*y_increament)}void main(){CPoin pt1(3,5),pt2(6,8);cout<<"The distance is"<<GetDistance(pt1,pt2)<<endl;}上面程序中的函数GetDistance()被说明为类CPoint类的友元函数,因为计算两个点之间距离这个函数很常用,而这个丽数显然同类CPoint有着密切的联系。

友元函数和友元类的定义及使用

友元函数和友元类的定义及使用

友元函数和友元类的定义及使用C++实验报告实验名称友元函数和友元类的定义及使用实验目的理解对象与类的关系,掌握对象的创建和使用掌握构造函数、析构函数的概念及使用方法掌握内存的动态分配的概念和使用方法掌握对象数组和对象指针掌握函数调用中参数的传递掌握友元函数和友元类的定义及使用class 类名 {private:数据成员或成员函数protected:数据成员或成员函数public:数据成员或成员函数};实验内容有Distance类和Point类,将Distance类定义为Point类的友元类来实现计算两点之间距离实验代码// point.hclass Distance;class Point{public:Point(int xx=0,int yy=0){X=xx;Y=yy;}friend class Distance;private:int X,Y;};class Distance{public:float fDist(Point a,Point b);};//point.cpp#include"iostream"#include"math.h"using namespace std;#include"point.h"#include"math.h"int _tmain(int argc, _TCHAR* argv[]){Point myp1(1,1),myp2(4,5);Distance d;cout<<"The distance is: ";cout<<d.fdist(myp1,myp2)<<endl;< p=""> return 0;}float Distance::fDist(Point p1,Point p2) {double x,y;x=p1.X -p2.X ;y=p1.Y -p2.Y ;return float(sqrt(x*x+y*y));}心得体会通过本次试验,让我更加熟练运用了友元函数和友元类的定义及使用,加快了学习的进程,知识的掌握实验名称运算符重载实验目的理解为什么要进行运算符重载,在什么情况下进行运算符重载。

c友元函数和友元类用法详解

c友元函数和友元类用法详解

c友元函数和友元类用法详解C++中的友元函数和友元类是一种特殊的函数和类,它们可以访问类的私有成员变量和类的私有成员函数。

本文将详细介绍C++中友元函数和友元类的用法,以及在实际编程中应用友元函数和友元类所带来的优势。

首先,让我们来了解一下C++中什么是友元函数和友元类。

友元函数是一种特殊的函数,它允许外部函数访问类的私有成员变量和私有成员函数,而不需要对类进行任何修改。

友元函数还可以在类外定义,以便更加方便地使用它来访问类的私有成员变量和私有成员函数。

友元类是一种特殊的类,它允许一个类的私有成员函数访问另一个类的私有成员函数和私有成员变量,而不需要对类进行任何修改。

友元类也可以定义在类外,但其功能与友元函数不同,友元类可以访问另一个类的整个实例,而友元函数只能访问另一个类的私有成员变量和私有成员函数。

定义友元函数和友元类的用法其实非常简单,我们只需要在类的声明中使用关键字“friend”来指定友元的函数或类就可以了: class A {private:int a;public:void setA (int a);friend void foo (A& A); //友元函数};class B {private:int b;public:void setB (int b);friend class C; //友元类};以上的代码定义了两个类:A类和B类,其中A类定义了一个友元函数foo,而B类定义了一个友元类C。

定义完友元函数和友元类之后,就可以使用它们来访问类的私有成员变量和私有成员函数了。

在实际使用中,友元函数和友元类有着诸多的优势,比如可以更加方便的封装类的私有成员,以及更加方便的实现代码的重构。

首先,友元函数和友元类可以帮助我们更好地封装类的私有成员,使类的私有成员不能被外部类访问。

同时,可以使用友元函数和友元类来实现类的重构,这样可以更加方便地实现代码的复用,让程序更加简洁和易读。

C++友元函数和友元类(C++friend)详解

C++友元函数和友元类(C++friend)详解私有成员只能在类的成员函数内部访问,如果想在别处访问对象的私有成员,只能通过类提供的接⼝(成员函数)间接地进⾏。

这固然能够带来数据隐藏的好处,利于将来程序的扩充,但也会增加程序书写的⿇烦。

是从结构化的C语⾔发展⽽来的,需要照顾结构化设计程序员的习惯,所以在对私有成员可访问范围的问题上不可限制太死。

C++ 设计者认为,如果有的程序员真的⾮常怕⿇烦,就是想在类的成员函数外部直接访问对象的私有成员,那还是做⼀点妥协以满⾜他们的愿望为好,这也算是眼前利益和长远利益的折中。

因此,C++ 就有了友元(friend)的概念。

打个⽐⽅,这相当于是说:朋友是值得信任的,所以可以对他们公开⼀些⾃⼰的隐私。

友元分为两种:友元函数和友元类。

友元函数在定义⼀个类的时候,可以把⼀些函数(包括全局函数和其他类的成员函数)声明为“友元”,这样那些函数就成为该类的友元函数,在友元函数内部就可以访问该类对象的私有成员了。

将全局函数声明为友元的写法如下:friend 返回值类型函数名(参数表);将其他类的成员函数声明为友元的写法如下:friend 返回值类型其他类的类名::成员函数名(参数表);但是,不能把其他类的私有成员函数声明为友元。

关于友元,看下⾯的程序⽰例。

1. #include<iostream>2. ug namespace std;3. class CCar; //提前声明CCar类,以便后⾯的CDriver类使⽤4. class CDriver5. {6. public:7. void ModifyCar(CCar* pCar); //改装汽车8. };9. class CCar10. {11. private:12. int price;13. friend int MostExpensiveCar(CCar cars[], int total); //声明友元14. friend void CDriver::ModifyCar(CCar* pCar); //声明友元15. };16. void CDriver::ModifyCar(CCar* pCar)17. {18. pCar->price += 1000; //汽车改装后价值增加19. }20. int MostExpensiveCar(CCar cars[], int total) //求最贵⽓车的价格21. {22. int tmpMax = -1;23. for (int i = 0; i<total; ++i)24. if (cars[i].price > tmpMax)25. tmpMax = cars[i].price;26. return tmpMax;27. }28. int main()29. {30. return 0;31. }这个程序只是为了展⽰友元的⽤法,所以 main 函数什么也不做。

第6讲 友元函数和友元类


友元函数
友元函数对类中成员的访问
– 一个类的友员函数与该类的类内成员函数一 样,享有对该类一切成员的访问权。 –但必须在参数表中显式指明要访问的对象。
友元函数的调用
–与一般函数的调用方式和原理一致。
一个函数可以是多个类的友元函数,不过需 要在各个类中分别声明
友元函数的定义和使用方法例子
#include <iostream.h> class X1 结果: { private: 用友元函数求各和:3 int x; 用普通函数调用类公共接口函数求和:3 public: X1(int i) { x=i; } void main() int getx(); { X1 m(1); friend void sum(X1 &a, X1 &b); //声明友元函数 X1 n(2); }; sum(m,n); int X1::getx() sum1(m,n); { return x;} } void sum(X1 &a,X1 &b) //定义函数 {cout<<"用友元函数求各和:"<<a.x+b.x<<endl; //可以访问类的私有成员} void sum1(X1 &a,X1 &b) //定义普通函数 {cout<< "用普通函数调用类公共接口函数求和:" <<a.getx()+b.getx()<<endl; }
友元的分类
友员函数 友员类
2.6.1 友元函数 友元函数
–是可以直接访问类的私有成员的非成员函数。 –它是在类外定义的普通函数,不属于任何类,但需要 在类的定义中加以声明

C++运算符重载三种形式(成员函数,友元函数,普通函数)详解

C++运算符重载三种形式(成员函数,友元函数,普通函数)详解三种重载⽅式⾸先,介绍三种重载⽅式:1//作为成员函数重载(常见)2class Person{3 Private:4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}8bool operator<(const Person& b);910 };11bool Person::operator<(const Person& b)12 {13//作为成员函数时,*this即为左操作数a14 ...15 }1//作为友元函数重载2class Person{3private:4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}8 friend bool operator<(const Person& a,const Person& b);910 };11bool operator<(const Person& a,const Person& b)12 {13 ...14 }1//作为普通函数重载(不推荐)2class Person{3public://注意,重载运算符为普通函数时,使⽤到的类成员必须为public4string name;5int age;6public:7 Person(const char* name, int age):name(name),age(age){}89 };10bool operator<(const Person& a,const Person& b)11 {12 ...13 }作为成员函数重载先介绍第⼀种:bool Person::operator<(const Person& b),bool是函数返回类型,Person::只是指定了成员函数所属类名。

友元函数详解

关于C++中的友元函数的总结1.友元函数的简单介绍1.1为什么要使用友元函数在实现类之间数据共享时,减少系统开销,提高效率。

如果类A中的函数要访问类B中的成员(例如:智能指针类的实现),那么类A中该函数要是类B的友元函数。

具体来说:为了使其他类的成员函数直接访问该类的私有变量。

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

实际上具体大概有下面两种情况需要使用友元函数:(1)运算符重载的某些场合需要使用友元。

(2)两个类要共享数据的时候。

1.2使用友元函数的优缺点1.2.1优点:能够提高效率,表达简单、清晰。

1.2.2缺点:友元函数破环了封装机制,尽量不使用成员函数,除非不得已的情况下才使用友元函数。

2.友元函数的使用2.1友元函数的参数:因为友元函数没有this指针,则参数要有三种情况:2.1.1要访问非static成员时,需要对象做参数;2.1.2要访问static成员或全局变量时,则不需要对象做参数;2.1.3 如果做参数的对象是全局对象,则不需要对象做参数;2.2友元函数的位置因为友元函数是类外的函数,所以它的声明可以放在类的私有段或公有段且没有区别。

2.3友元函数的调用可以直接调用友元函数,不需要通过对象或指针2.4友元函数的分类:根据这个函数的来源不同,可以分为三种方法:2.4.1普通函数友元函数2.4.1.1目的:使普通函数能够访问类的友元2.4.1.2语法:声明:friend + 普通函数声明实现位置:可以在类外或类中实现代码:与普通函数相同调用:类似普通函数,直接调用2.4.1.3代码:class INTEGER{friend void Print(const INTEGER& obj);//声明友元函数 };void Print(const INTEGER& obj){//函数体}void main(){INTEGER obj;Print(obj);//直接调用}2.4.2类Y的所有成员函数都为类X友元函数—友元类2.4.2.1目的:使用单个声明使Y类的所有函数成为类X的友元,它提供一种类之间合作的一种方式,使类Y的对象可以具有类X和类Y的功能。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

C++_友元函数转自:/insistgogo/article/details/66086721、为什么要引入友元函数:在实现类之间数据共享时,减少系统开销,提高效率具体来说:为了使其他类的成员函数直接访问该类的私有变量即:允许外面的类或函数去访问类的私有变量和保护变量,从而使两个类共享同一函数优点:能够提高效率,表达简单、清晰缺点:友元函数破环了封装机制,尽量不使用成员函数,除非不得已的情况下才使用友元函数。

2、什么时候使用友元函数:1)运算符重载的某些场合需要使用友元。

2)两个类要共享数据的时候3、怎么使用友元函数:友元函数的参数:因为友元函数没有this指针,则参数要有三种情况:1、要访问非static成员时,需要对象做参数;--常用(友元函数常含有参数)2、要访问static成员或全局变量时,则不需要对象做参数3、如果做参数的对象是全局对象,则不需要对象做参数友元函数的位置:因为友元函数是类外的函数,所以它的声明可以放在类的私有段或公有段且没有区别。

友元函数的调用:可以直接调用友元函数,不需要通过对象或指针友元函数的分类:根据这个函数的来源不同,可以分为三种方法:1、普通函数友元函数:a) 目的:使普通函数能够访问类的友元b) 语法:声明位置:公有私有均可,常写为公有声明:friend + 普通函数声明实现位置:可以在类外或类中实现代码:与普通函数相同(不加不用friend和类::)调用:类似普通函数,直接调用c) 代码:[cpp]view plaincopyprint?1.class INTEGER2.{3.private:4.int num;5.public:6.friend void Print(const INTEGER& obj);//声明友元函数7.};8.void Print(const INTEGER& obj)//不使用friend和类::9.{10.//函数体11.}12.void main()13.{14. INTEGER obj;15. Print(obj);//直接调用16.}2、类Y的所有成员函数都为类X友元函数—友元类a)目的:使用单个声明使Y类的所有函数成为类X的友元它提供一种类之间合作的一种方式,使类Y的对象可以具有类X和类Y的功能具体来说:前提:A是B的友元(=》A中成员函数可以访问B中有所有成员,包括私有成员和公有成员--老忘)则:在A中,借助类B,可以直接使用~B . 私有变量~的形式访问私有变量b)语法:声明位置:公有私有均可,常写为私有(把类看成一个变量)声明:friend + 类名---不是对象啊调用:c)代码:[cpp]view plaincopyprint?1.class girl;2.3.class boy4.{5.private:6.char *name;7.int age;8.public:9. boy();10.void disp(girl &);11.};12.13.void boy::disp(girl &x) //函数disp()为类boy的成员函数,也是类girl的友元函数14.{15. cout<<"boy's name is:"<<name<<",age:"<<age<<endl;//正常情况,boy的成员函数disp中直接访问boy的私有变量16. cout<<"girl's name is:"<<<<",age:"<<x.age<<endl;17.//借助友元,在boy的成员函数disp中,借助girl的对象,直接访问girl的私有变量18.//正常情况下,只允许在girl的成员函数中访问girl的私有变量19.}20.21.class girl23.private:24.char *name;25.int age;26.friend boy; //声明类boy是类girl的友元27.public:28. girl();29.};30.void main()31.{32. boy b;33. girl g;34. b.disp(g); //b调用自己的成员函数,但是以g为参数,友元机制体现在函数disp中35.}3、类Y的一个成员函数为类X的友元函数a)目的:使类Y的一个成员函数成为类X的友元具体而言:而在类Y的这个成员函数中,借助参数X,可以直接以X。

私有变量的形式访问私有变量b)语法:声明位置:声明在公有中(本身为函数)声明:friend + 成员函数的声明调用:先定义Y的对象y---使用y调用自己的成员函数---自己的成员函数中使用了友元机制c)代码:[cpp]view plaincopyprint?1.class girl;2.class boy3.{4.private:5.char *name;6.int age;7.public:8. boy();9.void disp(girl &);10.};12.class girl13.{14.private:15.char *name;16.int age;17.public:18. girl(char *N,int A);19.friend void boy::disp(girl &); //声明类boy的成员函数disp()为类girl的友元函数20.};21.22.void boy::disp(girl &x)23.{24. cout<<"boy's name is:"<<name<<",age:"<<age<<endl; //访问自己(boy)的对象成员,直接访问自己的私有变量25. cout<<"girl's name is:"<<<<",age:"<<x.age<<endl;26.//借助友元,在boy的成员函数disp中,借助girl的对象,直接访问girl的私有变量27.//正常情况下,只允许在girl的成员函数中访问girl的私有变量28.}29.void main()30.{31. boy b();32. girl g();33. b.disp(g); }4、在模板类中使用友元operator<<(对<<运算符的重载)a)使用方法:在模板类中声明:[cpp]view plaincopyprint?1.friend ostream& operator<< <>(ostream& cout,const MGraph<VexType,ArcType>& G);在模板类中定义:[cpp]view plaincopyprint?1.template<class VexType,class ArcType>2.ostream& operator<<(ostream& cout,const MGraph<VexType,ArcType>& G)3.{4.//函数定义5.}b)注意:把函数声明非模板函数:[cpp]view plaincopyprint?1.friend ostream& operator<< (ostream& cout,const MGraph& G);把函数声明为模板函数:[cpp]view plaincopyprint?1.friend ostream& operator<< <>(ostream& cout,const MGraph<VexType,ArcType>& G);或:[cpp]view plaincopyprint?1.friend ostream& operator<< <VexType,ArcType>(ostream& cout,const MGraph<VexType,ArcType>& G);说明:在函数声明中加入operator<<<>:是将operator<<函数定义为函数模板,将函数模板申明为类模板的友员时,是一对一绑定的实际的声明函数:这里模板参数可以省略,但是尖括号不可以省略[cpp]view plaincopyprint?1.friend ostream& operator<< <VexType,ArcType>(ostream& cout,const MGraph<VexType,ArcType>& G);5、友元函数和类的成员函数的区别:成员函数有this指针,而友元函数没有this指针。

6、记忆:A是B的友元《=》A是B的朋友《=》借助B的对象,在A中可以直接通过B。

成员变量(可以是公有,也可以为私有变量)的方式访问B。

相关文档
最新文档