成员函数、非成员函数和友元函数介绍

合集下载

友元函数及友元类

友元函数及友元类

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

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

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

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

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

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

关于这一点就这么简单。

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

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

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

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

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

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

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

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

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

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

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

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

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

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

C++中各种数据成员及成员函数的定义及使用

C++中各种数据成员及成员函数的定义及使用

C++中各种数据成员及成员函数的定义及使⽤转载于:1.类是⾃定义的数据类型.类与应⽤程序不同,类的功能虽然独⽴,但不能独⽴启动,就象汽车零件那样.2.Class 是⼀种数据类型, 其变量为对象.对象包含有member variables(成员变量)和member1 functions(成员函数).2class Date{3int year, month, day;4public:5void set(int y,int m,int d); // 赋值操作6bool isLeapYear(); // 判断闰年7void print(); // 输出⽇期8 };3.在类(class)中 , 成员函数及成员变量会分为两⼤类 : public members (公开成员)、private members (私有成员)1.) public members :被定义为public members 的成员函数及成员变量 , 可在任何的函数中被使⽤ .包括main函数,及其它⾮成员函数.2.) private members :被定义为private members 的成员函数及成员变量 , 只能在成员函数中被使⽤ .4.成员函数在类外部定义时,在函数名称前应加上⽇期类名前缀Date和命名空间引导符“::”,它表⽰着⾃⼰属于某⼀个名空间(类),与普通函数相区别。

1void Date::set(int y,int m,int d) { year=y; month=m; day=d; }成员函数可以在类内,也可以在类外定义,若在类内定义,则默认为内联函数(inline)5.对象是拥有操作的实体,是由类创建的6.访问成员函数的⽅式(1)对象⽅式 Date d; d.set(2011,12,5);(2)对象指针⽅式1 Date* dp = new Date;2 dp->set(2011,12,5);3// …4delete dp;7.成员函数的操作,如果只对对象进⾏读操作,则该成员函数可以设计为常对象成员函数,好处是让使⽤者⼀⽬了然的知道该成员函数不会改变对象值,同时让类的实现者更⽅便地调试。

C++中成员函数和友元函数的使用及区别详解

C++中成员函数和友元函数的使用及区别详解

C++中成员函数和友元函数的使⽤及区别详解为什么使⽤成员函数和友元函数这个问题⾄关重要,直接影响着后⾯的理解:程序数据:数据是程序的信息,会受到程序函数的影响。

封装是⾯向对象编程中的把数据和操作数据的函数绑定在⼀起的⼀个概念,这样能避免受到外界的⼲扰和误⽤,从⽽确保了安全。

数据封装引申出了另⼀个重要的 OOP 概念,即数据隐藏。

数据封装是⼀种把数据和操作数据的函数捆绑在⼀起的机制,数据抽象是⼀种仅向⽤户暴露接⼝⽽把具体的实现细节隐藏起来的机制。

C++ 通过创建类来⽀持封装和数据隐藏(public、protected、private)。

我们已经知道,类包含私有成员(private)、保护成员(protected)和公有成员(public)成员。

默认情况下,在类中定义的所有项⽬都是私有的。

由于C++的封装和隐藏特性,只有类定义的成员函数可以访问类定义的私有数据。

成员函数是数据封装和数据隐藏的机制。

友元是C++提供的⼀种破坏数据封装和数据隐藏的机制。

成员函数的使⽤⾸先先看代码class Stock{ //class declarationprivate:std:: string company;long shares;double share_val;double total_val;void set_tot(){ total_val=shares* share_val;}public:void acquire(const std:: string & co, long n, double pr);void buy(long num, double price);void se11(long num, double price);void update(double price);void show();};//note semicolon at the end注意这⾥⾯的private可以不写,如果不写的话默认是私有的。

友元函数——精选推荐

友元函数——精选推荐

友元函数友元⽅式:1、全局函数友元(外部);2、成员函数友元;3、类友元。

特点:1、单向;友元不具有传递性、友元不具有继承性。

对象的成员有数据和⽅法,⼀般将数据设置为private或保护,由于类的封闭性和隐藏性;将⽅法设置为public。

只有通过对象调动⼀般⽅法来访问其私有成员。

this指针存在于⾮静态成员函数中,则静态成员函数没有this指针,对于静态成员函数既可以在类⾥声明,在类外定义,也可以在类⾥定义。

友元函数:要解决静态成员函数访问其私有成员,则以将static函数前加friend修饰符,变为友元函数。

友元函数既可以在类⾥声明,在类外定义,还可以在类⾥定义。

友元函数是在类定义中由关键字friend修饰的⾮成员函数。

友元函数不是本类的成员函数,则调⽤时不能通过对象调⽤,直接⽤函数调⽤。

静态成员函数在调⽤时既可以通过对象调⽤,还可以通过函数名直接调⽤。

友元关系:1、将⼀个⾮成员函数getval()声明为类Test的友元函数,使得该⾮成员函数可以访问类Test的私有成员。

1、截图如下:在类⾥声明友元函数,在类外定义2、在类⾥声明友元函数,并定义//先将⾮成员函数在类声明;注意class Test;应在其之前声明,避免编译出错结果:(两次的结果为)成员函数友元3、将⼀个类Test的某成员函数声明为Base类的友元函数,使得可以通过 Test类的这个成员函数访问类Base的私有成员注意:被屏蔽的代码为编译出错代码,原因是由于Test类中的void getnum(Base &it)的成员函数被未设置为Base类的成员函数友元,则之后访问Base类中的私有成员,则会访问失败。

在Tes类中不能在声明getval(Base &x)的时候进⾏定义,因为此时的Base类并未定义,只是在Test类之前进⾏了声明⽽已。

类友元(将Test类声明为Base类的友元类,使得可以通过类Test对象访问类的私有成员)格式为:class B{...friend class A;}结果为:注意:在Tes类中不能在声明getval(Base &x)的时候进⾏定义,因为此时的Base类并未定义,只是在Test类之前进⾏了声明⽽已。

友元的概念和定义

友元的概念和定义

使用friend关键字 使用friend关键字,友元提供了在不同类的 friend关键字, 成员函数之间、 成员函数之间、类的成员函数与一般函数之间进 行数据共享的机制。通过友元, 行数据共享的机制。通过友元,一个普通函数或 另一个类中的成员函数可以访问类中的私有成员 和保护成员。 和保护成员。 友元的正确使用能提高程序的运行效率 提高程序的运行效率, 友元的正确使用能提高程序的运行效率,但 破坏了类的封装性和数据的隐蔽性, 破坏了类的封装性和数据的隐蔽性,导致程序可 维护性变差,因此一定要谨慎使用 谨慎使用。 维护性变差,因此一定要谨慎使用。 友元分为友元函数 友元成员和友元类三种 友元函数、 三种, 友元分为友元函数、友元成员和友元类三种, 友元声明可放在类的公有、私有或保护部分, 友元声明可放在类的公有、私有或保护部分,结 果是一样的。 果是一样的。
遵循一定规则而使对象以外的软件系统能够 不经过消息方式而直接访问对象内封装的数据成 友元。 员的技术方法便是友元 员的技术方法便是友元。友元是面向对象系统与 过程系统衔接的纽带。 过程系统衔接的纽带。 没有使用友元时的学生成绩管理系统。 例4.1 没有使用友元时的学生成绩管理系统。 友元函数定义则在类的外部, 友元函数定义则在类的外部,一般与类的成 员函数定义放在一起。因为类重用时, 员函数定义放在一起。因为类重用时,一般友元 是一起提供的。 是一起提供的。
4.4 友元类
某一个类可以是另一个类的友元, 某一个类可以是另一个类的友元 , 这 样作为友元的类中的所有成员函数都可以 访问另一个类中的私有成员。 访问另一个类中的私有成员。友元类的说 明方式如下: 明方式如下: 类名〉 friend class 〈类名〉; 友元类一。 自学) 【例4.6】友元类一。(自学) 友元类二。 【例4.7】友元类二。

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

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讲 友元函数和友元类

第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 中的FRIEND友元函数

C  中的FRIEND友元函数

C++中的friend友元函数(2011-03-2321:01:46)转载分类:C标签:friend友元教育友元函数是可以直接访问类的私有成员的非成员函数。

它是定义在类外的普通函数,它不属于任何类,但需要在类的定义中加以声明,声明时只需在友元的名称前加上关键字friend。

我们已知道类具有封装和信息隐藏的特性。

只有类的成员函数才能访问类的私有成员,程序中的其他函数是无法访问私有成员的。

非成员函数可以访问类中的公有成员,但是如果将数据成员都定义为公有的,这又破坏了隐藏的特性。

另外,应该看到在某些情况下,特别是在对某些成员函数多次调用时,由于参数传递,类型检查和安全性检查等都需要时间开销,而影响程序的运行效率。

为了解决上述问题,提出一种使用友元的方案。

友元是一种定义在类外部的普通函数,但它需要在类体内进行说明,为了与该类的成员函数加以区别,在说明时前面加以关键字friend。

友元不是成员函数,但是它可以访问类中的私有成员。

友元的作用在于提高程序的运行效率(即减少了类型检查和安全性检查等都需要的时间开销),但是,它破坏了类的封装性和隐藏性,使得非成员函数可以访问类的私有成员。

友元可以是一个函数,该函数被称为友元函数;友元也可以是一个类,该类被称为友元类。

友元函数的特点是能够访问类中的私有成员的非成员函数。

友元函数从语法上看,它与普通函数一样,即在定义上和调用上与普通函数一样。

#include"cmath"#include"iostream"using namespace std;class Point{public:Point(double xx,double yy){x=xx;y=yy;}void GetXY();friend double Distance(Point&a,Point&b);protected:private:double x,y;};void Point::GetXY(){//cout<<"("<<this->x<<","<<this->y<<")"<<endl;cout<<"("<<x<<","<<y<<")"<<endl;}double Distance(Point&a,Point&b){double length;length=sqrt((a.x-b.x)*(a.x-b.x)+(a.y-b.y)*(a.y-b.y));//它可以引用类中的私有成员return length;}int main(void){Point p1(3.0,4.0),p2(6.0,8.0);p1.GetXY();//成员函数的调用方法,通过使用对象来调用p2.GetXY();double d=Distance(p1,p2);//友元函数的调用方法,同普通函数的调用一样,不要像成员函数那样调用cout<<d<<endl;system("pause");return0;}说明:在该程序中的Point类中说明了一个友元函数Distance(),它在说明时前边加friend 关键字,标识它不是成员函数,而是友元函数。

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

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++知识点总结

C++知识点总结

类和对象初步1.类的定义在定义外成员函数的实现2.类的成员函数之间可以相互调用,类的成员函数也可以重载,也可设默认参数值3.一般来讲,一个对象占用的内存空间的大小等于其成员变量的体积之和。

每个对象都有自己的存储空间(成员变量),但成员函数只有一份对象名.成员名指针->成员名引用名.成员名4.private:一个类的私有成员,只能在该类的成员函数中才能访问public:proteced:5.class默认private struct默认public6.内联成员函数:成员函数名前加inline 或函数体写在类定义内部的成员函数。

执行更快,但会带来额外的内存开销构造函数1.构造函数全局变量在堆上,系统自动初始化为零。

局部变量在栈上,初始值是随机的,需要初始化。

2.构造函数:对对象进行初始化。

构造函数执行时对象的内存空间已经分配,构造函数的作用是初始化这片空间.可重载,不写的话有默认构造函数,但是如果编写了构造函数,那默认构造函数不会再执行.是一类特殊的成员函数。

不写返回值类型,函数名为类名.3.对象在生成时一定会调用某个构造函数,一旦生成,不再执行构造函数.4.P183 Ctest *pArray[3]={new Ctest(4),new Ctest(1,2)}5.复制构造函数:其是构造函数的一种,只有一个参数,为本类的引用,防止混淆,构造函数不能以本类的对象作为唯一的参数。

默认复制构造函数。

6.复制构造函数被调用的三种情形:1用一个对象去初始化另一个对象时Complex C1(C2)ComplexC2=C1; 2 函数的参数是类A的对象。

形参未必等于实参函数中用对象的引用不会调用复制构造函数void Function(const Complex &c)3 函数的返回值是类A的对象7.类型转换构造函数:除复制构造函数外,只有一个参数的构造函数C=68.析构函数:在对象消亡时调用,可以定义其做善后工作。

c++名词解释

c++名词解释

C++名词解释
重载函数:允许在作用域内定义多个同名函数,使这些同名函数表示类似的操作。

引用:引用是给对象取的一个别名.
构造函数:构造函数是类的一个特殊成员函数,它的函数名与类名相同,它可以有任意类型的参数,但不能具有返回类型。

创建一个对象时,自动调用构造函数。

析构函数:析构函数处理对象的善后工作,函数名与类名相同,但它前面必须有一个~;它没有参数,也没有返回类型。

友元:允许外面的类或函数去访问一个类的私有数据。

纯虚函数:是一个在基类中说明的虚函数,它在该基类中没有定义,要求仍何派生类都必须定义自己的版本。

内联函数:指用inline关键字修饰的函数。

在类内定义的函数被默认成纯虚函数。

派生类:利用继承机制,新的类可以从已有的类中派生。

继承:通过继承机制,可以利用已有的数据类型来定义新的数据类型。

所定义的新的数据类型不仅拥有新定义的成员,而且还同时拥有旧的成员。

我们称已存在的用来派生新类
多态:通过继承相关的不同的类,它们的对象能够对同一函数调用作出不同的响应,它是通过虚函数实现的。

虚函数:在基类中被冠以virtual的成员函数,它提供了一种接口界面。

虚基类:在C++中,一个类不能被多次说明为一个派生类的直接基类,但可以不止一次地成为间接基类。

模板:C++语言具有类属机制的叫模板。

C++学习之路—运算符重载(二)运算符重载作为类的成员函数和友元函数

C++学习之路—运算符重载(二)运算符重载作为类的成员函数和友元函数

C++学习之路—运算符重载(⼆)运算符重载作为类的成员函数和友元函数对运算符重载的函数有两种处理⽅式:(1)把运算符重载的函数作为类的成员函数;(2)运算符重载的函数不是类的成员函数,在类中把它声明为友元函数。

1 把运算符重载函数作为类的成员函数例1:为了便于说明问题,将重载函数的定义重写如下:1: Complex Complex :: operator + ( Complex& c2 )2: {3: Complex c ;4: c.real = real + c2.real ;5: c.imag = imag + c2.imag ;6:return c ;7: }有⼈可能会提出这样的疑问:“+”是双⽬运算符,为什么重载函数只有⼀个参数呢?实际上,运算符重载函数应当有两个参数,但是,由于重载函数是Complex类中的成员函数,因此有⼀个参数是隐含的,运算符函数是⽤this指针隐式的访问类对象的成员。

可以看到operator+访问了两个对象中的成员,⼀个是this指针指向的对象中的成员,⼀个是形参对象中的成员。

2 把运算符重载函数作为类的友元函数运算符重载函数除了可以作为类的成员函数外,还可以是⾮成员函数。

在有关的类中把它声明为友元函数,即友元运算符重载函数。

例2:将运算符+重载为适⽤于复数加法,重载函数不作为成员函数,⽽放在类外,作为Complex类的友元函数。

1:class Complex2: {3:public:4: ...5:friend Complex operator + ( Complex& c1 , Complex& c2 ) ; //重载函数作为友元函数6:private:7:double real ;8:double imag ;9: };10:11: Complex operator + ( Complex& c1 , Complex& c2 ) //定义运算符+重载函数12: {13: Complex c ;14: c.real = c1.real + c2.real ;15: c.imag = c1.imag + c2.imag ;16:return c ;17: }这个程序和把运算符重载函数作为类的成员函数相⽐,只做了⼀处改动,就是将运算符重载函数作为类外的普通函数,并在Complex类中声明它为友元函数。

c++关于友元函数的例子

c++关于友元函数的例子

1. 友元定义:一般来说,仅仅只有类的成员函数能访问类的私有或者保护成员,如果我们声明一个公共的函数作为这个类的友元,这个函数也可以访问类的私有成员。

友元是C++里面用来破坏类的封装的一个机制。

我们可以使用类的友元或者类的友元函数.2.友元函数友元函数是类的非成员函数(普通函数),在类的里面声明,必须在函数前面加上关键词“friend”。

和普通函数类似,友元函数能够在类的里面或者外面被实现。

友元函数必须通过类的对象名来访问类的数据成员。

友元函数的例子-computing distance between two points源程序:#include <iostream.h>#include <math.h>class Point{public:Point(double xx=0, double yy=0);double GetX() {return X;}double GetY() {return Y;}friend double Dist(Point &a, Point &b);private:double X,Y;};Point::Point(double xx, double yy){X=xx; Y=yy;}double Dist( Point& a, Point& b){double dx=a.X-b.X;double dy=a.Y-b.Y;return sqrt(dx*dx+dy*dy);}void main(){Point p1(3.0, 5.0), p2(4.0, 6.0);double d=Dist(p1, p2);cout<<"The distance is "<<d<<endl;cout<<p1.GetX()<<"\t"<<p1.GetY()<<endl; }运行结果:3. 友元类如果一个B类是另一个A类的友元,那么B类所有的成员函数能够访问A类的所有成员,反之,亦然。

成员运算符函数

成员运算符函数

程序运行结果如下: 2.3+4.6i 3.6+2.8i 5.9+7.4i -1.3+1.8i -4.6+29.44i 1.01731+0.486538i
从本例可以看出,对复数重载了这些运算符后, 再进行复数运算时,不再需要按照给出的表达 式进行繁琐的运算,只需像基本数椐类型的运 算一样书写即可,这样给用户带来了很大的方 便,并且很直观。
一般而言,采用成员函数重载单目运算符 时,可以采用以下两种方法来使用:
@aa;
//隐式调用
aa.operator@();
//显式调用
成员运算符函数operator@所需的一个操作数 由对象aa通过this指针隐含地传递。因此,在 它的参数表中没有参数。
说明:
(1)运算符重载函数operator@()可以返回任何类 型,甚至可以是void类型,但通常返回类型与它所操 作的类的类型相同,这样可使重载运算符用在复杂的 表达式中。例如,在例4-3中,可以将几个复数连续进 行加,减,乘,除的运算。
本 例 主 函 数 main() 中 调 用 成 员 运 算 符 ++operator++()采用了两种方式:
++ob;

ob.operator++();
两者是等价的,其执行结果完全相同。
从本例还可以看出,当成员函数重载单目 运算符时,没有参数被显式地传递给成员运算 符函数。参数是通过this指针隐藏地传递给函 数的。
A6=A1.operator/(A2);
由此我们可以看出,成员运算符函数 operator@实际上是由双目运算符左边的对象 A1调用的,尽管双目运算符函数的参数表只有 一个操作数是由对数A1通过this指针隐含地传 递的。以上两组语句的执行结果是完全的。

友元函数

友元函数

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

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

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

友元函数的调用:可以直接调用友元函数,不需要通过对象或指针友元函数的分类:根据这个函数的来源不同,可以分为三种方法:1、普通函数友元函数:a) 目的:使普通函数能够访问类的友元b) 语法:声明位置:公有私有均可,常写为公有声明:friend + 普通函数声明实现位置:可以在类外或类中实现代码:与普通函数相同(不加不用friend和类::)调用:类似普通函数,直接调用c) 代码:2、类Y的所有成员函数都为类X友元函数—友元类a)目的:使用单个声明使Y类的所有函数成为类X的友元它提供一种类之间合作的一种方式,使类Y的对象可以具有类X和类Y的功能具体来说:前提:A是B的友元(=》A中成员函数可以访问B中有所有成员,包括私有成员和公有成员--老忘)则:在A中,借助类B,可以直接使用~B . 私有变量~的形式访问私有变量b)语法:声明位置:公有私有均可,常写为私有(把类看成一个变量)声明:friend + 类名---不是对象啊调用:c)代码:3、类Y的一个成员函数为类X的友元函数a)目的:使类Y的一个成员函数成为类X的友元具体而言:而在类Y的这个成员函数中,借助参数X,可以直接以X。

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() 是一个全局范围内的非成员函数,它不属于任何类,它的作用是输出学生的信息。

友元函数

友元函数

1.4 将一个函数(全局或成员的)声明为多个类的友元函数
在这种情况下,该函数可以同时访问多个类的 private 成员。
class Date; //对 Date 类的提前引用声明 class Time{ public: Time(int=1,int=1,int=1); friend void call(Time&,Date&);//声明函数 call 为本类的友元成员函数 private: int hour; int min; int sec; }; class Date{ public: Date(int=1,int=1,int=2008); friend void call(Time&,Date&); //声明函数 call 为本类的友元成员函数 private: int year; int mon; int day; }; Time::Time(int h,int m,int s){ hour=h; min=m; sec=s; } Date::Date(int m,int d,int y){ mon=m; day=d; year=y; } void call(Time &t,Date &d) {
cout<<"TIME:"<<t.hour<<"-"<<t.min<<"-"<<t.sec<<endl; cout<<"DATE:"<<d.mon<<"-"<<d.day<<"-"<<d.year<<endl; } int main(){ Time t; Date d; call(t,d); system("PAUSE"); return EXIT_SUCCESS; }

类模板的友元函数

类模板的友元函数

类模板的友元函数友元函数是在 C++ 中具有特殊访问权限的函数。

通过友元函数,可以让函数访问类的私有成员。

友元函数可以是全局函数,也可以是其他类的成员函数。

在使用类模板时,我们也可以定义友元函数,以实现对类模板的访问与操作。

一、友元函数的概念和作用1.友元函数的概念友元函数是在类定义中声明为 friend 的非成员函数。

这意味着该函数可以直接访问类的私有和受保护成员,而不需要通过对象进行访问。

相比之下,普通的非成员函数只能通过对象来访问类的公有成员。

2.友元函数的作用友元函数的作用在于,它可以访问类的私有成员和受保护成员,而不破坏类的封装性。

友元函数可以在需要使用类的私有成员或者受保护成员的时候,提供一种方便的访问方式。

二、类模板的说明和使用1.类模板的定义类模板是一种通用的类定义,它可以被用来创建具有不同数据类型的对象。

类模板在定义时可以指定其中的成员变量和成员函数的数据类型,但通常不会指定具体的数值。

2.类模板的使用使用类模板时,需要在类名后面用尖括号指定具体的数据类型。

例如,定义一个类模板 Stack,用于实现栈结构,在声明一个 Stack 对象时,可以指定栈中元素的数据类型,比如 int 或者 char。

三、类模板的友元函数定义和声明1.类模板的友元函数定义类模板的友元函数可以在类名后紧跟着友元函数的声明,也可以在类的内部直接定义友元函数。

例如,在 Stack 类模板中定义一个友元函数 PrintStack,用于打印栈中的元素。

在类模板定义的内部,可以直接使用类模板的成员。

template <typename T>class Stack {private:T* data;int top;public:Stack();void push(const T& item);T pop();friend void PrintStack(const Stack& s) {for (int i = 0; i <= s.top; i++) {cout << s.data[i] << " ";}cout << endl;}};在上述代码中,PrintStack 函数是 Stack 类的友元函数,可以直接访问 Stack 类的私有成员 data 和 top。

什么是友元函数

什么是友元函数

什么是友元函数?
答:和继承一样,可以说子继承父,友元就是朋友,它不是类的组成部分,因此被称为直接函数调用。

友元函数不能隐式访问类成员,而必须将成员操作符用于作为参数传递的对象。

友元函数要在一个类体内说明,形式为:friend 类型名友元函数名(形参表);然后在类体外对友元函数进行定义,定义的格式和普通函数相同,但可以通过对象作为参数直接访问对象的私有成员;
友元函数说明如下:①.必须在类的说明中说明友元函数,说明时以关键字friend开头,后跟友元函数的函数原型,友元函数的说明可以出现在类的任何地方,包括在private和public 部分。

②注意友元函数不是类的成员函数,所以友元函数的实现和普通函数一样,在实现时不用”::”指示属于那个类,只有成员函数才使用”::”作用域符号。

③友元函数不能直接访问类的成员,只能访问对象成员。

④友元函数可以访问对象的私有成员,但普通函数不行;⑤调用友元函数时,在实际参数中需要指出要访问的对象!。

c++笔记15静态成员和友元

c++笔记15静态成员和友元

静态成员的需要性静态成员的使用静态数据成员静态成员函数需要友元的原因友元的使用私有成员和保护成员提供了方便,但破坏了类的封装性和隐蔽性。

友元可以是一个函数,称为友元函数,也可以是一个类,称为友元类。

友元函数和友元类统称为友元。

一、静态成员的需要性类相当于一个数据类型,当说明一个某类的对象时,系统就为该对象分配一块内存单元来存放类中的所有成员。

但在某些应用中,需要程序中属于某个类的所有对象共享某个数据。

为此,一个解决的办法就是将所要共享的数据说明为全局变量,但这将破坏数据的封装性;较好的解决办法是将所要共享的数据说明为类的静态成员。

二、静态成员的使用C++中在说明类成员(数据成员和成员函数)时,使用了static关键字,则这类成员称为类的静态成员。

静态成员是所有对象公有的。

静态成员有静态数据成员和静态函数成员之分。

C++中,同一个类定义多个对象时,每个对象拥有各自的数据成员(不包括静态数据成员),而所有对象共享一份成员函数和一份静态数据成员。

静态数据成员是类的所有对象中共享的成员,而不是某个对象的成员,因此可以实现多个对象间的数据共享。

静态数据成员不属于任何对象,它不因对象的建立而产生,也不因对象的析构而删除,它是类定义的一部分, 所以使用静态数据成员不会破坏类的隐蔽性。

对静态数据成员的操作和一般数据成员一样,定义为私有的静态数据成员不能由外界访问。

静态数据成员可由任意访问权限许可的函数访问。

可以在类的成员函数中改变静态数据成员。

静态数据成员不从属于任何一个具体对象,所以必须对它初始化,且对静态数据成员的初始化不能在构造函数中进行。

类中用关键字static修饰的数据成员叫做静态数据成员。

说明一个静态数据成员的方法与说明一个一般静态变量一样,只不过前者是在一个类中说明。

静态数据成员的使用方法如下:1) 静态数据成员的定义与一般数据成员相似,但前面要加上static关键词。

2) 静态数据成员的初始化与一般数据成员不同,静态数据成员初始化的格式如下:<类型> <类名>::<静态数据成员>=<值>;int Student :: noOfStudents = 0;3)在引用静态数据成员时采用格式:<类名>::<静态数据成员>几点注意:⏹静态数据成员是类的一部分,静态数据成员的定义是类定义的一部分,将其放在类的内部实现部分中定义。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。
2、静态函数: 类中,static 型的成员函数,由于是类所拥有的,而不是具体对象所有的。 静态函数屏蔽了 this 指针,因此,如果成员函数作为回调函数,就应该用 static 去修饰它。
3、虚函数: 虚函数首先是一种成员函数,它可以在该类的派生类中被重新定义并被赋予另外一种处理功能。 注意多态不是函数重载。函数重载属于静态绑定,虚函数实现多态是动态绑定。
strcpy(Internet::address,address);
} friend void ShowN(Internet &obj,Country &cn);//注意这里
public:
char name[20];
char address[20];
};
class Country
{
public:
Country()
成员函数、非成员函数和友元函数介绍
一、成员函数、非成员函数和友元函数 成员函数和非成员函数最大的区别在于成员函数可以是虚拟的而非成员函数不行。
成员函数的优势是能够方便的进行动态绑定,实现多态。 说明一个函数为一个类的友元函数则该函数可以访问此类的私有数据和方法。
二、成员函数介绍 1、显式构造函数 C++中的 exp是显式的。 隐式构造函数能够实现将该构造函数对应数据类型的数据转换为该类对象。 class MyClass { public: MyClass( int num ); } MyClass obj = 10; //ok,convert int to MyClass 如果在构造函数前加上关键字 explicit,上述编译出错。
Public:
//…
Circle *clone () const ;
//…
}; 三、友元函数
友元函数的定义方法是在类的定义中,在函数名前加上关键字 friend。友元函数并不能看做是类的成 员函数, 它只是个被声明为类友元的普通函数,因此实现时不能加类的作用域。
一个普通函数可以是多个类的友元函数。
一个类的成员函数函数也可以是另一个类的友元,从而可以使得一个类的成员函数可以操作另一个类的 数据成员。
定义方法是在友元类中定义类的作用域如在类 B 中定义 A 的成员函数 test 为类 B 友元函数: friend void A::test(int &temp) 友元函数作为多个类的友元函数示例:
{ strcpy(cname,"中国");
} friend void ShowN(Internet &obj,Country &cn);//注意这里
protected:
char cname[30];
};
void ShowN(Internet &obj,Country &cn) {
cout<<ame<<"|"<<<<endl; } 四、非成员函数 静态函数、内联函数和非静态函数 。
4、纯虚函数: 在抽象类中定义纯虚函数,必须在子类实现,不过子类也可以只是声明为纯虚函数,由 子类的子类实现。
5、协变返回类型: 一般来说,一个重写的函数与被它重写的函数必须具有相同的返回类型。 这个规则对于”协变返回类型(covariant return type)”的情形来说有所放松. 也就是说,若 B 是一个类类型,并且一个基类虚拟函数返回 B *,那么一个重写的派生类函数可以返回 D *, 其中的 D 公有派生于 B(即 D 是一个(is-a)B).若基类虚函数返回 B &,那么一个重写的派生类函数可以返回一 个 D&. 考虑如下一个 shape 层次结构的 clone 操作: Class Shape { Public: //… Virtual Shape *clone () const = 0; //prototype(原型) //… }; Class Circle : public Shape {
class Country;
class Internet
{
public: Internet(char *name,char *address)
// 改为:internet(const char *name , const char *ad
dress)
{
strcpy(Internet::name,name);
相关文档
最新文档