友元函数及友元类

友元函数及友元类
友元函数及友元类

友元函数及友元类

已有 20621 次阅读 2009-5-9 15:43 |个人分类:C/C++

什么是友元(friend)?

允许另一个类或函数访问你的类的东西。

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

分清成员函数,非成员函数和友元函数

成员函数和非成员函数最大的区别在于成员函数可以是虚拟的而非成员函数不行。所以,如果有个函数必须进行动态绑定,就要采用虚拟函数,而虚拟函数必定是某个类的成员函数。关于这一点就这么简单。如果函数不必是虚拟的,情况就稍微复杂一点。

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

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

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

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

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

?在类定义中声明友元函数时,需在其函数名前加上关键字friend。此声明可以放在公有部分,也可以放在私有部分。友元函数可以定义在类的内部,也可以定义在类的外部。

1.友元函数虽然可以访问类对象的私有成员,但它毕竟不是成员函数。因此,在类的外部定义友元函数时,不必像成员函数那样,在函数名前加上“类名::”。

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

3.当一个函数需要访问多个类时,友元函数非常有用,普通的成员函数只能访问其所属的类,但是多个类的友元函数能够访问相应的所有类的数据。

例程序2使用一个友元函数访问两个不同的类

4.友元函数通过直接访问对象的私有成员,提高了程序运行的效率。在某些情况下,如运算符被重载时,需要用到友元。但是友元函数破坏了数据的隐蔽性,降低了程序的可维护性,这与面向对象的程序设计思想是背道而驰的,因此使用友元函数应谨慎。

?除了一般的函数可以作为某个类的友元外,一个类的成员函数也可以作为另一个类的友元,这种成员函数不仅可以访问自己所在类对象中的私有成员和公有成员,还可以访问friend声明语句所在类对象中的私有成员和公有成员,这样能使两个类相互合作、协调工作,完成某一任务。

?例程序3使用友元成员函数访问另一个类

说明:

1.一个类的成员函数作为另一个类的友元函数时,必须先定义这个类。例如上例中,类boy的成员函数为类girl的友元函数,必须先定义类boy。并且在声明友元函数时,要加上成员函数所在类的类名,如:

friend void boy::disp(girl &);

2.程序中还要使用“向前引用”,因为函数disp()中将girl &作为参数,而girl要晚一些时候才定义。

?不仅函数可以作为一个类的友元,一个类也可以作为另一个类的友元。这种友元类的说明方法是在另一个类声明中加入语句“friend 类名;”,其中的“类名”即为友元类的类名。此语句可以放在公有部分也可以放在私有部分,例如:

class Y{

//……

};

class X{

//……

friend Y;

//……

};

?当一个类被说明为另一个类的友元时,它的所有的成员函数都成为另一个类的友元函数,这就意味着为友元的类中的所有成员函数都可以访问另一个类的私有成员。

例程序4友元类

说明:

1.友元关系是单向的,不具有交换性(我是你的朋友,不能推断出:你是我的朋友)。

2.友元关系也不具有传递性(我是你的朋友,你是他的朋友,不能推断出:我是他的朋友)。

通过下面几个程序我们来了解一下友元函数

程序1 使用友元函数

#include

#include

class girl{

private:

char *name;

int age;

public:

girl(char *n,int d)

{ name=new char[strlen(n)+1];

strcpy(name,n);

age=d;

}

friend void disp(girl &); //声明为友元函数

~girl(){delete name;}

};

void disp(girl &x) //定义友元函数

{

cout<<"girl\'s name

is:"<<https://www.360docs.net/doc/0d12471960.html,<<",age:"<<x.age<<endl;

}

void main()

{

girl e("Chen Xingwei",18);

disp(e); //调用友元函数

}

程序2使用一个友元函数访问两个不同的类

#include <iostream.h>

#include

class boy; //向前引用

class girl{

char name[25];

int age;

public:

void init(char N[],int A);

friend void prdata(const girl plg,const boy plb); //声明函数为girl 类的友元函数

};

void girl::init(char N[],int A)

{ strcpy(name,N);

age=A;

}

class boy{

char name[25];

int age;

public:

void init(char N[],int A);

friend void prdata(const girl plg,const boy plb); //声明函数为boy类的友元函数

};

void boy::init(char N[],int A)

{ strcpy(name,N);

age=A;

}

void prdata(const girl plg,const boy plb)

{

cout<<"女孩"<<https://www.360docs.net/doc/0d12471960.html,<<','<<plg.age<<"岁;";

cout<<"男孩

"<<https://www.360docs.net/doc/0d12471960.html,<<','<<plb.age<<"岁。\n";

}

void main()

{ girl G1,G2,G3;

boy B1,B2,B3;

G1.init("Stacy",12);

G2.init("Judith",13);

G3.init("Leah",12);

B1.init("Jim",11);

B2.init("Micheal",13);

B3.init("Larry",12);

prdata(G1,B1);

prdata(G2,B2);

prdata(G3,B3);

}

程序3使用友元成员函数访问另一个类

#include <iostream.h>

#include

class girl; //向前引用

class boy{

char *name;

int age;

public:

boy(char *N,int A)

{ name=new char[strlen(N)+1];

strcpy(name,N);

age=A;

}

void disp(girl &); //声明disp()为类boy的成员函数

~boy(){delete name;}

};

class girl{

char *name;

int age;

public:

girl(char *N,int A)

{ name=new char[strlen(N)+1];

strcpy(name,N);

age=A;

}

friend void boy::disp(girl &); //声明类boy的成员函数disp()为类girl 的友元函数

~girl(){delete name;}

};

void boy::disp(girl &x)

{

cout<<"boy\'s name

is:"<<name<<",age:"<<age<<endl; //访问本类对象成员

cout<<"girl\'s name

is:"<<https://www.360docs.net/doc/0d12471960.html,<<",age:"<<x.age<<endl; //访问友元类对象成员

}

void main()

{ boy b("chen hao",25);

girl g("zhang wei",18);

b.disp(g);

}

友元类

程序4 boy为girl的友元类

#include <iostream.h>

#include

class girl;

class boy{

char *name;

int age;

public:

boy(char *n,int d)

{ name=new char[strlen(n)+1];

strcpy(name,n);

age=d;

}

void disp(girl &); //声明disp()为类boy的成员函数

~boy(){delete name;}

};

class girl{

char *name;

int age;

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

public:

girl(char *n,int d)

{ name=new char[strlen(n)+1];

strcpy(name,n);

age=d;

}

~girl(){delete name;}

};

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

{ cout<<;"boy\'s name is:"<

is:"<<https://www.360docs.net/doc/0d12471960.html,<<",age:"<<x.age<<endl;

}

void main()

{ boy b("chen hao",25);

girl g("zhang wei",18);

b.disp(g);

}

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

成员函数、非成员函数和友元函数介绍 一、成员函数、非成员函数和友元函数 成员函数和非成员函数最大的区别在于成员函数可以是虚拟的而非成员函数不行。 成员函数的优势是能够方便的进行动态绑定,实现多态。 说明一个函数为一个类的友元函数则该函数可以访问此类的私有数据和方法。 二、成员函数介绍 1、显式构造函数 C++中的e xplicit关键字用来修饰类的构造函数,表明该构造函数是显式的。 隐式构造函数能够实现将该构造函数对应数据类型的数据转换为该类对象。 class MyClass { public: MyClass( int num); } MyClass obj = 10; //ok,convert int to MyClass 如果在构造函数前加上关键字explicit,上述编译出错。 2、静态函数: 类中,static型的成员函数,由于是类所拥有的,而不是具体对象所有的。 静态函数屏蔽了this指针,因此,如果成员函数作为回调函数,就应该用static去修饰它。 3、虚函数: 虚函数首先是一种成员函数,它可以在该类的派生类中被重新定义并被赋予另外一种处理功能。 注意多态不是函数重载。函数重载属于静态绑定,虚函数实现多态是动态绑定。 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 {

友元函数及友元类

友元函数及友元类 已有 20621 次阅读 2009-5-9 15:43 |个人分类:C/C++ 什么是友元(friend)? 允许另一个类或函数访问你的类的东西。 友元可以是函数或者是其他的类。类授予它的友元特别的访问权。通常同一个开发者会出于技术和非技术的原因,控制类的友元和成员函数(否则当你想更新你的类时,还要征得其它部分的拥有者的同意)。 分清成员函数,非成员函数和友元函数 成员函数和非成员函数最大的区别在于成员函数可以是虚拟的而非成员函数不行。所以,如果有个函数必须进行动态绑定,就要采用虚拟函数,而虚拟函数必定是某个类的成员函数。关于这一点就这么简单。如果函数不必是虚拟的,情况就稍微复杂一点。 ?类的主要特点之一是数据隐藏,即类的私有成员只能在类定义的范围内使用,也就是说私有成员只能通过它的成员函数来访问。 ?但是,有时候需要在类的外部访问类的私有成员。为此,就需要寻找一种途径,在不放弃私有数据安全性的情况下,使得类外部的函数或类能够访问类中的私有成员,在C++中就用友元作为实现这个要求的辅助手段。 ?C++中的友元为数据隐藏这堵不透明的墙开了一个小孔,外界可通过这个小孔窥视类内部的秘密,友元是一扇通向私有成员的后门。 ?友元可分为:友元函数,友元成员,友元类。 ?友元函数不是当前类的成员函数,而是独立于当前类的外部函数,但它可以访问该类的所有对象的成员,包括私有成员和公有成员。 ?在类定义中声明友元函数时,需在其函数名前加上关键字friend。此声明可以放在公有部分,也可以放在私有部分。友元函数可以定义在类的内部,也可以定义在类的外部。

1.友元函数虽然可以访问类对象的私有成员,但它毕竟不是成员函数。因此,在类的外部定义友元函数时,不必像成员函数那样,在函数名前加上“类名::”。 2.友元函数一般带有一个该类的入口参数。因为友元函数不是类的成员,所以它不能直接引用对象成员的名称,也不能通过this指针引用对象的成员,它必须通过作为入口参数传递进来的对象名或对象指针来引用该对象的成员。 3.当一个函数需要访问多个类时,友元函数非常有用,普通的成员函数只能访问其所属的类,但是多个类的友元函数能够访问相应的所有类的数据。 例程序2使用一个友元函数访问两个不同的类 4.友元函数通过直接访问对象的私有成员,提高了程序运行的效率。在某些情况下,如运算符被重载时,需要用到友元。但是友元函数破坏了数据的隐蔽性,降低了程序的可维护性,这与面向对象的程序设计思想是背道而驰的,因此使用友元函数应谨慎。 ?除了一般的函数可以作为某个类的友元外,一个类的成员函数也可以作为另一个类的友元,这种成员函数不仅可以访问自己所在类对象中的私有成员和公有成员,还可以访问friend声明语句所在类对象中的私有成员和公有成员,这样能使两个类相互合作、协调工作,完成某一任务。 ?例程序3使用友元成员函数访问另一个类 说明: 1.一个类的成员函数作为另一个类的友元函数时,必须先定义这个类。例如上例中,类boy的成员函数为类girl的友元函数,必须先定义类boy。并且在声明友元函数时,要加上成员函数所在类的类名,如: friend void boy::disp(girl &); 2.程序中还要使用“向前引用”,因为函数disp()中将girl &作为参数,而girl要晚一些时候才定义。 ?不仅函数可以作为一个类的友元,一个类也可以作为另一个类的友元。这种友元类的说明方法是在另一个类声明中加入语句“friend 类名;”,其中的“类名”即为友元类的类名。此语句可以放在公有部分也可以放在私有部分,例如: class Y{

实验8--友元函数与运算符重载函数

实验十三 1.实验目的 通过本次实验 (1)理解友元函数与运算符重载函数的概念; (2)学会友元函数的定义与使用方法; (3)掌握运算符重载函数的定义与使用方法; 2.实验要求 (1)编写实验程序 (2)在VC++运行环境中,输入源程序 (3)编译运行源程序 (4)输入测试数据进行程序测试; (5)写出运行结果。 3.实验内容 (1)定义一个复数类,重载“-=”运算符,使这个运算符能直接完成复数的“-=”运算。分别用成员函数与友元函数编写运算符重载函数。在主函数中定义复数对象c1(10,20)、c2(15,30),进行c2-=c1的复数运算,并输出c1、c2的复数值。 参考资料: (1)成员函数 # include class Complex { private: float Real,Image; public: Complex(float r=0,float i=0) { Real=r;Image=i;} void Show(int i) { cout<<"c"< class Complex { private: float Real,Image; public: Complex(float r=0,float i=0) { Real=r;Image=i;} void Show(int i) { cout<<"c"<

友元函数实验报告

课程名称:VC++程序设计 专业名称 班级 学号 姓名 实验(4): 实验日期 【实验名称】 友元 【实验目的】

1)了解为什么要使用友元 2)掌握友元函数、友元成员、友元类的定义和使用方法 【实验内容和结果】 1. 定义复数complex类,使用友元,完成复数的加法、减法、乘法、除法运算,以及对复数的输出。 #include using namespace std; //复数加法公式: //复数减法公式: //复数乘法公式: //复数除法公式: class complex{ double real; double image; public: complex(double r=0,double i=0){ real=r; image=i; } friend void inputcomplex(complex&com); friend complex addcomplex(complex&c1,complex&c2); friend complex subcomplex(complex&c1,complex&c2); friend complex mulcomplex(complex&c1,complex&c2); friend complex divcomplex(complex&c1,complex&c2); friend void outputcomplex(complex&com); }; void inputcomplex(complex &com){ cin>>com.real>>com.image; } complex addcomplex(complex&c1,complex&c2){ complex c; c.real=c1.real+c2.real; c.image=c1.image+c2.image; return c; } complex subcomplex(complex&c1,complex&c2){ complex c; c.real=c1.real-c2.real; c.image=c1.image-c2.image; return c;

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

C++_友元函数 转自:https://www.360docs.net/doc/0d12471960.html,/insistgogo/article/details/6608672 1、为什么要引入友元函数:在实现类之间数据共享时,减少系统开销,提高效率 具体来说:为了使其他类的成员函数直接访问该类的私有变量 即:允许外面的类或函数去访问类的私有变量和保护变量,从而使两个类共享同一函数 优点:能够提高效率,表达简单、清晰 缺点:友元函数破环了封装机制,尽量不使用成员函数,除非不得已的情况下才使用友元函数。 2、什么时候使用友元函数: 1)运算符重载的某些场合需要使用友元。 2)两个类要共享数据的时候 3、怎么使用友元函数: 友元函数的参数: 因为友元函数没有this指针,则参数要有三种情况: 1、要访问非static成员时,需要对象做参数;--常用(友元函数常含有参数) 2、要访问static成员或全局变量时,则不需要对象做参数 3、如果做参数的对象是全局对象,则不需要对象做参数 友元函数的位置: 因为友元函数是类外的函数,所以它的声明可以放在类的私有段或公有段且没有区别。 友元函数的调用: 可以直接调用友元函数,不需要通过对象或指针

友元函数的分类: 根据这个函数的来源不同,可以分为三种方法: 1、普通函数友元函数: a) 目的:使普通函数能够访问类的友元 b) 语法:声明位置:公有私有均可,常写为公有 声明:friend + 普通函数声明 实现位置:可以在类外或类中 实现代码:与普通函数相同(不加不用friend和类::) 调用:类似普通函数,直接调用 c) 代码: [cpp]view plaincopyprint? 1.class INTEGER 2.{ 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的友元

VC6.0中重载操作符友元函数无法访问类的私有成员的解决办法

VC6.0中重载操作符友元函数无法访问类的私有成员的解决办法 VC6.0中重载操作符友元函数无法访问类的私有成员的解决办法: 在C++中,操作符(运算符)可以被重载以改写其实际操作。 同时我们可以定义一个函数为类的友元函数(friend function)以便使得这个函数能够访问类的私有成员,这个定义通常在头文件中完成。 在Visual C++中定义一般的函数为友元函数通常是没有问题的。然而对某些重载操作符的函数,即使我们将它们定义为类的友元函数,VC的编译器仍然会显示出错信息,认为这些友元函数无权访问类的私有成员。我认为这应该是VC6.0编译器与标准C++不兼容的地方。 以下代码就是个例子: // 头文件“Sample.h” #include using namespace std; class Sample{ public: Sample( ); friend ostream &operator<<(ostream &out, const Sample s); friend istream &operator>>(istream &in, Sample & s); private: int x; }; // 实现文件“Sample.cpp” #include “Sample.h” Sample::Sample( ) { x=0; } istream &operator>>(istream &in, Sample & s) { cout<<”Please enter a value”<> s.x ; return in; } ostream &operator<<(ostream &out, const Sample s) { cout << s.x << endl; return out; } 以上代码在gnuc++中编译运行毫无问题。但是在VC++6.0中编译的时候就会出现以下的编

【例6.4】用友元函数重载运算符实现两字符串加法

【例6.4】用友元函数重载运算符实现两字符串加法。 #include #include class String { char name[256]; public: String(char* str) { strcpy(name,str); } String(){ } ~String(){ } friend String operator+(const String&, const String&); void display() { cout<<"The string is :"<

static char* str; String operator+(const String& a,const String& b) { strcpy(str,https://www.360docs.net/doc/0d12471960.html,); strcat(str,https://www.360docs.net/doc/0d12471960.html,); return String(str); } void main() { str=new char[256]; String demo1("Visual c++"); String demo2(" 6.0"); demo1.display(); demo2.display(); String demo3=demo1+demo2; demo3.display(); String demo4=demo3+" Programming."; demo4.display(); String demo5="Programming."+demo4; demo5.display();

delete str; } 程序的运行结果为: The string is :Visual c++ The string is : 6.0 The string is :Visual c++ 6.0 The string is :Visual c++ 6.0 Programming. The string is :Programming.Visual c++ 6.0 Programming.

实用C语言中friend友元函数详细解析

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(x,y)endl;

vc中操作符重载作为友元函数错误处理

VC6.0中重载操作符函数无法访问类的私有成员 在C++ 中,操作符(运算符)可以被重载以改写其实际操作。 同时我们可以定义一个函数为类的朋友函数(friend function)以便使得这个函数能够访问类的私有成员, 这个定义通常在头文件中完成。 在Visual C++中定义一般的函数为朋友函数通常是没有问题的。 然而对某些重载操作符的函数, 即使我们将它们定义为类的朋友函数,VC的编译器仍然会显示出错信息, 认为这些朋友函数无权访问类的私有成员。 我认为这应该是VC6.0的bug。 以下代码就是个例子: // 头文件“Sample.h” #include using namespace std; class Sample { public: Sample(); friend ostream &operator<<(ostream &out, const Sample s); friend istream &operator>>(istream &in, Sample & s); private: int x; }; // 实现文件“Sample.cpp” #include “Sample.h” Sample::Sample() { x=0; } istream &operator>>(istream &in, Sample & s) { cout<<”Please enter a value”<> s.x ; return in; } ostream &operator<<(ostream &out, const Sample s) { cout << s.x << endl; return out; }

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

C++实验报告 实验名称 友元函数和友元类的定义及使用 实验目的 理解对象与类的关系,掌握对象的创建和使用 掌握构造函数、析构函数的概念及使用方法 掌握内存的动态分配的概念和使用方法 掌握对象数组和对象指针 掌握函数调用中参数的传递 掌握友元函数和友元类的定义及使用 class 类名 { private: 数据成员或成员函数 protected: 数据成员或成员函数 public: 数据成员或成员函数 }; 实验内容 有Distance类和Point类,将Distance类定义为Point类的友元类来实现计算两点之间距离 实验代码 // point.h class 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<

实验八 友元函数与友元类

实验八友元函数与友元类 1、实验目的 掌握友元函数和友元类的说明方法,理解友元函数和友元类的使用特点。 2、实验内容 (1)设计一个包含两个整数数据成员的类,利用友元函数求这两个数的平方差。 // 123.cpp : 定义控制台应用程序的入口点。 // #include"stdafx.h" #include using namespace std; class number { private : int a,b; public: number(int c,int d) { a=c; b=d; } friend void calculate(number &n) { cout<

#include"stdafx.h" #include using namespace std; //计一个班级类(专业名,班级号,个学生的姓名,个学生的成绩), //再设计一个友元函数求该班级学生中的的最高分和最低分,并输出对应的分数和姓名。class classscore { private : char major; int classnumber; char name; int score; public: classscore (int m,int cn,char n,int s) { major=m; cn=classnumber; name=n; score=s; } friend void highlow(classscore cs[10]) { int max=0,min=100,maxi=0,mini=0; for(int i=0;i<10;i++) { if (cs[i].score>max) { maxi=i; max=cs[i].score; } if (cs[i].score

静态成员和友元函数

实验三静态成员和友元函数实验名称:静态成员和友元函数学时安排:2 实验类别:设计性实验实验要求:1人1组 一、实验目的和任务 1)熟练掌握友元函数设计的方法 2)掌握友元函数的含义,友元函数和成员函数的区别。 二、实验原理介绍 根据要求正确定义静态成员和友元函数。将别的模块声明为友元,使类中本隐藏的信息如私有和保护成员就可以被友元访问。 三、实验设备介绍 软件需求: Visual C++ 6.0 硬件需求: 对于硬件方面的要求,建议配置是Pentium III 450以上的CPU处理器,64MB 以上的内存,200MB的自由硬盘空间、CD-ROM驱动器、能支持24位真彩色的显示卡、彩色显示器、打印机。 四、实验内容和步骤 【实验3-1】静态成员 为账户类ACCOUNT增加静态成员count和 InterestRate表示账户数量和利率, 增加静态成员函数GetCount返回账户数目 GetInterestRate返回银行利率 class ACCOUNT { public: ACCOUNT(string accno,string name,float balance); ~ACCOUNT(); void Deposit(float amount); void Withdraw(float amount); float GetBalance(); void Show(void); static int GetCount(); static float GetInterestRate(); private: static int count; static float InterestRate; string _accno,_accname; float _balance; };

友元函数

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)代码:

相关主题
相关文档
最新文档