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++友元函数&友元类
友元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++中什么是友元函数和友元类。
友元函数是一种特殊的函数,它允许外部函数访问类的私有成员变量和私有成员函数,而不需要对类进行任何修改。
友元函数还可以在类外定义,以便更加方便地使用它来访问类的私有成员变量和私有成员函数。
友元类是一种特殊的类,它允许一个类的私有成员函数访问另一个类的私有成员函数和私有成员变量,而不需要对类进行任何修改。
友元类也可以定义在类外,但其功能与友元函数不同,友元类可以访问另一个类的整个实例,而友元函数只能访问另一个类的私有成员变量和私有成员函数。
定义友元函数和友元类的用法其实非常简单,我们只需要在类的声明中使用关键字“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.概述
①友元:是定义⼀个类是,该主动声明哪些其他类或函数是它的朋友,进⽽给他们定向提供对类的访问特权。
②友元是C++提供的⼀种破坏数据封装和数据隐藏的机制。
③通过友元将⼀个模块声明为另⼀个模块的友元,⼀个模块能够引⽤到另⼀个模块中本是被隐藏的信息。
④可以使⽤友元函数和友元类。
建议:为了确保数据完整性,及数据封装与隐藏原则,建议尽量不使⽤或少使⽤。
2、友元函数
①友元函数是在类的声明中由关键字friend修饰说明的⾮成员函数,在它的函数体中能通过对象名访问 private和protected 成员。
②作⽤:增加灵活性,使程序员可以在封装和快速性⽅⾯做合理选择。
③访问对象中的成员必须通过对象名。
④友元是单向的。
友元函数的定义⽅法(以定义⼀个Point类为例)
(该函数传⼊引⽤,节约⼯耗)
此时,就会遇到在函数中改变对象私有信息的危险,破坏数据的封装。
例如:
输出:
对⽐原先的输出:
如果想防⽌对象的私有数据被更改 , 可以在传⼊引⽤时加 const修饰例如:
这样在函数中再想更改对象的私有数据时就会报错,例如:
⾄于const的⽤法相信⼤家都见过了,在后⾯的博客中会加以补充。
跟我学C++语言编程技术——友员函数与友员类
友员类应用目的 在类的封装和共享两方面合理选择:类的主要优 点是实现数据隐藏与保护,从而将数据与方法相 互组合产生独立的代码块,但这样将使各个类相 互孤立,无法实现类之间的共享。但在应用需求 中可能要实现多个类之间的共享,这可以采用友 元类的方式来实现。
类的引用性前向说明 当类名使用在定义之前时,需要使用前向说明以便 编译器知道此标识符是类名,从而正确地编译。
为什么需要友员函数
在封装和快速性两方面合理选择----OOP中类的 主要优点是可以实现数据隐藏与保护,即不允许 非成员函数对它访问,这样可以提高数据使用的 安全性。但在访问数据的效率方面则下降(因为 正常时应该通过public型的方法பைடு நூலகம்访问)。但在 某些应用场合下,非成员函数体中需要通过对象 名直接访问类中的private成员,以达到高速高效 率地访问数据,这可以通过友员函数来实现。 有些函数需要放在类的外面或者类设计完以后再 加以补充的,此时可能不能设计为类中的成员函 数,但是又需要访问类中的私有成员。
友员函数与成员函数在编程方面的不同点
友员函数在类体内应该采用 friend 加以限定, 但成员函数不需要。 友员函数体在类体外不需要采用“类名::”加以 限定。 调用它时不需要采用“对象名.成员名”方式, 而是直接调用它。 由于友员函数不是成员函数,因而无this指针, 在函数体中访问对象中的成员时必须通过对象 名(可将形参定义为引用),而在成员函数体 内可以直接访问成员数据。
本讲的回顾
在本讲的最后对本讲做一个简要的回顾
友员函数与一般函数(非成员函数)在编程方面的 不同点 友员函数在类体内应该采用 friend 加以限定,但 非成员函数不需要在类中声明。 在友员函数体内可以利用对象访问类中的 private 成员,但非成员函数则不能。
c++友元函数、友元类声明和使用
c++友元函数、友元类声明和使⽤转⾃:友元函数(friend function)1. 什么是友元函数?⼀个类的私有数据成员通常只能由类的函数成员来访问,⽽友元函数可以访问类的私有数据成员,也能访问其保护成员2. 友元函数的⽤处体现在哪⾥?2.1 使⽤友元函数可提⾼性能,如:⽤友元函数重载操作符和⽣成迭代器类2.2 ⽤友元函数可以访问两个或多个类的私有数据,较其它⽅法使⼈们更容易理解程序的逻辑关系3. 使⽤友元函数前应注意:3.1 类的友元函数在类作⽤域之外定义,但可以访问类的私有和保护成员3.2 尽管类定义中有友元函数原型,友元函数仍然不是成员函数3.3 由于友元函数不是任何类的成员函数,所以不能⽤句柄(对象)加点操作符来调⽤3.4 public, private, protected成员访问符与友员关系的声明⽆关,因此友元关系声明可在类定义的任何位置,习惯上在类定义的开始位置 3.5 友元关系是指定的,不是获取的,如果让类B成为类A的友元类,类A必须显式声明类B为⾃⼰的友元类3.6 友元关系不满⾜对称性和传递性3.7 如果⼀个友元函数想与两个或更多类成为友元关系,在每个类中都必须声明为友元函数4. 注:由于C++属于混合语⾔,常在同⼀个程序中采⽤两种函数调⽤且这两种函数调⽤往往是相反的。
类C语⾔的调⽤将基本数据或对象传递给函数,C++调⽤则是将函数(或信息)传递给对象#include <iostream>using namespace std;class Car{friend void display(Car); //类"Car"的朋友display() //友元函数的声明private:int speed;char color[20];public:void input( ){cout<<"Enter the color : ";cin>>color;cout<<"Enter the speed : ";cin>>speed;}};void display(Car x) //友元函数的定义{cout<<"The color of the car is : "<<x.color<<endl;cout<<"The speed of the car is : "<<x.speed<<endl;}int main( ){Car mine;mine.input( ); //访问成员函数display(mine); //友元函数的使⽤ //将对象"mine"传给友元函数return 0;}输出结果:Enter the color: green 回车Enter the speed: 100 回车The color of the car is : greenThe speed of the car is : 100#include <iostream>using namespace std;class Virus; //类'Virus'未定义前要⽤到,需事先告诉编译器'Virus'是⼀个类class Bacteria{private:int life;public:Bacteria() { life=1; }friend void Check(Bacteria, Virus); //类'Bacteria'中,将Check声明为友元函数};class Virus{private:int life;public:Virus() : life(0) {}friend void Check(Bacteria, Virus); //类'Virus'中,将Check声明为友元函数};void Check (Bacteria b, Virus v) //友元函数的定义{if (b.life==1 || v.life==1){cout<<"\nSomething is alive.";}if (b.life==1){cout<<"\nA bacteria is alive.";}if (v.life==1){cout<<"\nA virus is alive.";}}int main() { Bacteria fever; Virus cholera; Check(fever, cholera); //友元函数的调⽤ return 0; } 输出结果: Something is alive. A bacteria is alive. 友元类(frie nd class) 1. 友元类可以访问与之为友元关系的类的所有私有成员 2. 友元类使⽤较少 #include <iostream> using namespace std; class Add { private: int x,y; public: Add() { x=y=4; } friend class Support; //类'Support'现在是类'Add'的朋友 }; class Support { public: void Sum(Add ob)//此函数可访问类'Add'的所有私有成员{ cout<<"The sum of the 2 members is : "<<(ob.x+ob.y)<<endl; } }; int main() { Add ad; Support sup; sup.Sum(ad); return 0; } 输出结果: The sum of the 2 members is : 8。
C++复习5大基础函数(析构函数、构造函数、内联函数、拷贝构造函数、友元函数)详解
1、析构函数2、构造函数3、内联函数4、拷贝构造函数5、友元函数1、析构函数是类的一种特殊的成员函数,它会在每次删除所创建的对象时执行。
析构函数的名称与类的名称是完全相同的,只是在前面加了个波浪号(~)作为前缀,它不会返回任何值,也不能带有任何参数。
析构函数有助于在跳出程序(比如关闭文件、释放内存等)前释放资源。
2、构造函数是类的一种特殊的成员函数,它会在每次创建类的新对象时执行。
构造函数的名称与类的名称是完全相同的,并且不会返回任何类型,也不会返回void。
构造函数可用于为某些成员变量设置初始值。
3、内联函数有时称作在线函数(inline)。
函数的调用是需要付出一定的时空开销的,因为系统在调用函数时,要保留现场,然后转入被调用函数去执行,调用完,再返回主调函数,此时再恢复现场,这些操作。
所谓“内联函数”就是将很简单的函数“内嵌”到调用他的程序代码中,只样做的目的是为了节约下原本函数调用时的时空开销。
但必须注意的是:作为内联函数,函数体必须十分简单,不能含有循环、条件、选择等复杂的结构,否则就不能做为内联函数了。
事实上,即便你没有指定函数为内联函数,有的编译系统也会自动将很简单的函数作为内联函数处理;而对于复杂的函数,即便你指定他为内联函数,系统也不会理会的。
内联函数也有一定的局限性。
就是函数中的执行代码不能太多了,如果,内联函数的函数体过大,一般的编译器会放弃内联方式,而采用普通的方式调用函数。
这样,内联函数就和普通函数执行效率一样了。
4、拷贝构造函数拷贝构造函数,又称复制构造函数。
复制构造函数是一种特殊的构造函数,函数的名称必须和类名称一致,它必须的一个参数是本类型的一个引用变量。
它在创建对象时,是使用同一类中之前创建的对象来初始化新创建的对象.为什么需要拷贝构造函数?把参数传递给函数有三种方法,一种是传值,一种是传地址,一种是传引用。
传值与其他两种方式不同的地方在于当使用传值方式的时候,会在函数里面生成传递参数的一个副本,这个副本的内容是按位从原始参数那里复制过来的,两者的内容是相同的。
C++课件第十二章类的其它特性(友元、虚函数、静态成员)
友元函数
友元函数是一个独立的函数,它被声明为类的友元,从而可以访问类的私有和保护 成员。
友元函数不是类的成员函数,但它可以像成员函数一样访问类的私有和保护成员。
友元函数通常用于实现运算符重载、类型转换等。
友元类
友元类是一个完整的类,它被声 明为另一个类的友元。
友元类可以访问另一个类的所有 成员,包括私有和保护成员。
类和对象的创建与销毁
创建
使用关键字new来创建类的对象。new操作符会在堆上分配内存,并返回指向 新创建对象的指针。
销毁
使用关键字delete来销毁类的对象。delete操作符释放由new分配的内存,并 执行对象的析构函数。
感谢您的观看
THANKS
静态数据成员的初始化只进行一次,且 在类外部进行。
静态成员函数
静态成员函数是属于类本身而非类的对象的函数。 静态成员函数可以在没有创建类的对象的情况下调用。
静态成员函数只能访问静态数据成员和静态常量数据成员。
04
运算符重载
什么是运算符重载
01
运算符重载是指允许程序员为类 定义特殊的运算符行为,使得这 些运算符在类中具有特殊的意义 和功能。
可见性
描述了变量、函数和类的可访问 性。C提供了四种类型的可见性: public、protected、private和 default(没有标识符)。
类模板和模板类
类模板
允许定义一个通用的类,该类可以处 理多种数据类型。类模板使用尖括号 <>定义,并在尖括号中指定模板参 数。
模板类
使用类模板定义的类称为模板类。模 板类可以创建不同类型的对象,并使 用不同的数据类型来处理数据。
数。
动态绑定和静态绑定
C++总结 友元类和友元函数
C++总结友元类和友元函数《windows环境多线程编程原理与应用》中解释:如果将类的封装比喻成一堵墙的话,那么友元机制就像墙上了开了一个门,那些得到允许的类或函数允许通过这个门访问一般的类或者函数无法访问的私有属性和方法。
友元机制使类的封装性得到消弱,所以使用时一定要慎重。
友元类的说明将外界的某个类在本类别的定义中说明为友元,那么外界的类就成为本类的“朋友”,那个类就可以访问本类的私有数据了。
class Merchant{private :intm_MyMoney;intm_MyRoom;… …public:Friend class Lawyer;Intgetmoney();… …};class Lawyer{private:… …public:… …};只有你赋予某个类为你的友元时,那个类才有访问你的私有数据的权利。
说明一个函数为一个类的友元函数则该函数可以访问此类的私有数据和方法。
定义方法是在类的定义中,在函数名前加上关键字friend.《挑战30天C/C++》这样解释:在说明什么是友元之前,我们先说明一下为什么需要友元与友元的缺点:通常对于普通函数来说,要访问类的保护成员是不可能的,如果想这么做那么必须把类的成员都生命成为public(共用的),然而这做带来的问题遍是任何外部函数都可以毫无约束的访问它操作它,c++利用friend修饰符,可以让一些你设定的函数能够对这些保护数据进行操作,避免把类成员全部设置成public,最大限度的保护数据成员的安全。
友元能够使得普通函数直接访问类的保护数据,避免了类成员函数的频繁调用,可以节约处理器开销,提高程序的效率,但所矛盾的是,即使是最大限度大保护,同样也破坏了类的封装特性,这即是友元的缺点,在现在cpu速度越来越快的今天我们并不推荐使用它,但它作为c++一个必要的知识点,一个完整的组成部分,我们还是需要讨论一下的。
在类里声明一个普通数学,在前面加上friend修饰,那么这个函数就成了该类的友元,可以访问该类的一切成员。
C++ friend友元函数和友元类
友元函数和友元类在实际开发中较少使用,想快速学习C++的读者可以跳过本节。
一个类中可以有public、protected、private 三种属性的成员,通过对象可以访问public 成员,只有本类中的函数可以访问本类的private 成员。
现在,我们来介绍一种例外情况——友元(friend)。
借助友元(friend),可以使得其他类中的成员函数以及全局范围内的函数访问当前类的private 成员。
fnend 的意思是朋友,或者说是好友,与好友的关系显然要比一般人亲密一些。
我们会对好朋友敞开心扉,倾诉自己的秘密,而对一般人会谨言慎行,潜意识里就自我保护。
在C++中,这种友好关系可以用friend 关键字指明,中文多译为“友元”,借助友元可以访问与其有好友关系的类中的私有成员。
如果你对“友元”这个名词不习惯,可以按原文friend 理解为朋友。
友元函数在当前类以外定义的、不属于当前类的函数也可以在类中声明,但要在前面加friend 关键字,这样就构成了友元函数。
友元函数可以是不属于任何类的非成员函数,也可以是其他类的成员函数。
友元函数可以访问当前类中的所有成员,包括public、protected、private 属性的。
1) 将非成员函数声明为友元函数。
请大家直接看下面的例子:1.#include<iostream>ing namespace std;3.4.class Student{5.public:6.Student(char*name,int age,float score);7.public:8.friend void show(Student *pstu);//将show()声明为友元函数9.private:10.char*m_name;11.int m_age;12.float m_score;13.};14.15.Student::Student(char*name,int age,float score):m_name(name),m_age(age),m_score(score){}16.17.//非成员函数18.void show(Student *pstu){19.cout<<pstu->m_name<<"的年龄是"<<pstu->m_age<<",成绩是"<<pstu->m_score<<endl;20.}21.22.int main(){23.Student stu("小明",15,90.6);24.show(&stu);//调用友元函数25.Student *pstu =new Student("李磊",16,80.5);26.show(pstu);//调用友元函数27.28.return0;29.}运行结果:小明的年龄是15,成绩是90.6李磊的年龄是16,成绩是80.5show() 是一个全局范围内的非成员函数,它不属于任何类,它的作用是输出学生的信息。
友元(友元函数、友元类和友元成员函数)C++
友元(友元函数、友元类和友元成员函数)C++有些情况下,允许特定的⾮成员函数访问⼀个类的私有成员,同时仍阻⽌⼀般的访问,这是很⽅便做到的。
例如被重载的操作符,如输⼊或输出操作符,经常需要访问类的私有数据成员。
友元(frend)机制允许⼀个类将对其⾮公有成员的访问权授予指定的函数或者类,友元的声明以friend开始,它只能出现在类定义的内部,友元声明可以出现在类中的任何地⽅:友元不是授予友元关系的那个类的成员,所以它们不受其声明出现部分的访问控制影响。
通常,将友元声明成组地放在类定义的开始或结尾是个好主意。
1、友元函数友元函数是指某些虽然不是类成员函数却能够访问类的所有成员的函数。
类授予它的友元特别的访问权,这样该友元函数就能访问到类中的所有成员。
#include <iostream>using namespace std;class A{public:friend void set_show(int x, A &a); //该函数是友元函数的声明private:int data;};void set_show(int x, A &a) //友元函数定义,为了访问类A中的成员{a.data = x;cout << a.data << endl;}int main(void){class A a;set_show(1, a);return0;}2、友元类友元类的所有成员函数都是另⼀个类的友元函数,都可以访问另⼀个类中的隐藏信息(包括私有成员和保护成员)。
当希望⼀个类可以存取另⼀个类的私有成员时,可以将该类声明为另⼀类的友元类。
关于友元类的注意事项:(1) 友元关系不能被继承。
(2) 友元关系是单向的,不具有交换性。
若类B是类A的友元,类A不⼀定是类B的友元,要看在类中是否有相应的声明。
(3) 友元关系不具有传递性。
若类B是类A的友元,类C是B的友元,类C不⼀定是类A的友元,同样要看类中是否有相应的申明。
- 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 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。