当前位置：文档之家 › 实验二_类的静态数据成员和友元

实验二_类的静态数据成员和友元

  • 格式：pdf
  • 大小：222.43 KB
  • 文档页数：8

下载文档原格式

  / 8

合集下载

静态成员和友元函数

静态成员和友元函数

实验三静态成员和友元函数实验名称：静态成员和友元函数学时安排：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;};【实验3-2】友元函数为账户类ACCOUNT增加一个友元函数，实现账户结息，要求输出结息后的余额（不计算利息税），并在main函数中调用进行测试。

friend void Update(ACCOUNT& a);【实验3-3】（加分题）在main函数中，设计一个ACCOUNT类型的数组，为数组中的10个对象初始化，并调用成员函数测试存款、取款、显示等函数，再调用友元函数测试进行结息。

静态成员和友元

静态成员和友元
16
类 的 静 态 成 员
Point::Point(Point &p) { X=p.X; Y=p.Y; countP++; }; int Point::countP=0; void main() //主函数实现 { Point A(4,5);//声明对象A cout<<"Point A,"<<A.GetX()<<","<<A.GetY(); A.GetC(); //输出对象号，对象名引用 Point B(A); //声明对象B cout<<"Point B,"<<B.GetX()<<","<<B.GetY(); Point::GetC(); //输出对象号，类名引用 }
11
类 的 静 态 成 员
• •
静态数据成员可应用在以下几个方面： (1)用来保存流动变化的对象个数(如学生 人数)；
•
(2) 作为一个标志，指示一个特定的动作 是否发生；
(3) 指向一个链表的第一成员或最后一个 成员的指针。
•
12
静态成员函数
• 引入原因
－ 对static数据成员的访问。
• 定义
22
友元成员函数
类 的 友 元
一个类的成员函数可以说明为另一个类 的友元，以便通过该成员函数访问另一个 类中的成员

23
类 的 友 元
友元类

若一个类为另一个类的友元，则此类的所 有成员都能访问对方类的私有成员。

声明语法：将友元类名在另一个类中使用 friend修饰说明。
24
友元类举例

《静态成员与友元》课件

《静态成员与友元》课件
与一般的非静态成员相比，静态成员是类的共享成员，它不依赖于类的实例 而存在，并且在类的所有实例之间是共享的。
静态成员的作用
静态成员可以在类的实例之间共享数据和函数。它们可以用于跟踪类的所有 实例的共同状态，或提供与类相关的全局操作。
静态成员的声明与初始化
静态成员在类的定义中声明，并在类外部进行初始化。它们的生命周期与程序的运行周期相同，直到程序结束。
友元的定义
友元是一种特殊的关系，允许其他类或函数访问另一个类的私有成员。它可以增加程序的灵活性和扩展性。
友元函数与友元类
友元函数是指在类的定义中声明为友元的非成员函数，可以访问该类的私有 成员。友元类是指在类的定义中声明为友元的另一个类。
实例演示
让我们通过一个例子来演示静态成员和友元的用法。我们将创建一个类来管 理学生的信息，并使用静态成员和友元来实现一些特殊操作。
《静态成员与友元》PPT课件
静态成员的定义 静态成员与非静态成员的区别 静态成员演示
静态成员的定义
在C++中，静态成员是类的成员，其属于类本身而不是类的实例。可以通过类 名加作用域运算符(::)来访问静态成员。
静态成员与非静态成员的区别

静态成员与友元

静态成员与友元
总结
静态成员属于类本身，只有一个实例，存储在静态存储区，而友元不属于类本身，可以访问类的私有和 保护成员，但不能访问类的静态成员。
使用场景的比较
静态成员
适用于需要在程序中全局访问或管理的数据或函数，例如计数器、 单例模式等。
友元
适用于需要访问类的私有和保护成员的外部函数或类，例如输入 输出流、字符串处理函数等。
02
在某些算法中，需要使用到类 的私有和保护成员，这时可以 使用友元函数来提供访问权限 。
03
在实现某些设计模式（如策略 模式）时，可能需要使用友元 函数来提供对类的内部状态的 访问。
友元函数与成员函数的区别
访问权限
01
友元函数可以访问类的私有和保护成员，而成员函数只能访问
公有成员。
调用方式
02
友元函数不是通过对象来调用的，而成员函数是通过对象来调
总结
静态成员适用于需要全局访问或管理的数据或函数，而友 元适用于需要访问类的私有和保护成员的外部函数或类。
04
示例代码
静态成员函数示例
总结词
静态成员函数属于类本身，而不是类的对象。它们可以在没有类的对象的情况下调用。
详细描述
静态成员函数可以直接通过类名调用，而不需要类的对象实例。它们通常用于实现与类相关但不依赖于类中特定 对象的功能。例如，一个计算类中静态成员函数可以计算两个数的和或差，而不关心具体是哪两个数。
友元函数可以是一个全局函数、另一个 类的成员函数或一个嵌套函数。
友元函数不是类的成员函数，但它可以 访问类的非静态成员变量，但不能访问 静态成员变量。
特点
友元函数不受类的访问控制限制，可以 直接访问类的私有和保护成员。
友元函数的使用场景

静态成员和友元

静态成员和友元
一个函数需要经常而且大量地访问一个
类的数据成员 一个类从属于另一个类，而且一般不单 独使用，而是通过另一个类的对象来发 挥使用。 运算符重载
12.2.3友员---注意的问题
– 友员函数和一般的函数没有什么区别， 它独立于类之外 – 友员函数是对类操作的一种补充 – 友员不是成员，不能用this指针来访 问它
修改类File，使能对程序中生成的文件对象计数
File::~File() { delete[] contents;
FileCount --；
}
对程序中生成的文件对象计数
#include <iostrem.h> #include “File.h” int FileCount = 0; void main(){ cout << “File number:“ << FileCount <<endl; File f1; File f2("myfile"); File *pFile = new File(“Newfile"); cout << “File number:“ << FileCount <<endl; delete pFile; cout << “File number:“ << FileCount <<endl; }
例2 ---看下面程序的执行结果
void main( ) { Student s; cout<<s.number( )<<endl; //用对象引用静态成 员函数 cout<<Student::number( )<<endl; // 用类名引 用静态成员函数 } 运行结果

静态成员与友元

静态成员与友元






#include "iostream.h" class b {private : int no; int age; public: b(int i,int j) {no=i; age=j; } void pr() {cout<<no<<" "<<age<<endl;} friend class a; }; class a {public: void print(b m) {cout<<m.no<<" "<<m.age;} };
10.3 友元应用实例





#include <iostream.h> class Myclass { private: int a,b,max,min; public: Myclass(int i,int j):a(i),b(j) { max=(a>b)?a:b; min=(a<b)?a:b; } friend int Result(Myclass& x); }; int Result(Myclass & x) { return x.max*x.max-x.min*x.min; } void main() { Myclass n(3,4); cout<<Result(n)<<endl; }
定义友元函数的方式是在类定义中用关键词 friend说明该函数， 其格式如下： friend <类型> <友元函数名> （<参数表>）；
友元函数说明的位置可在类的任何部位，既可在public区，也 可在protected区，意义完全一样。友元函数定义则在类的外部，一 般与类的成员函数定义放在一起。 类的友元函数可以直接访问该类的所有成员，但它不是成员 函数，可以像普通函数一样在任何地方调用。友员函数的定义方 法是在类的任何地方象定义其他函数一样定义该函数,并在其前面 加上关键字friend即可。 友员函数虽然在类内定义，但它不是这个 类的成员函数，它可以是一个普通函数，也可以是其他类的成员 函数，在其函数体中通过对象名访问这个类的私有或保护成员。

静态成员与友元

南昌航空大学实验报告二00七年月日课程名称：面向对象程序设计实验名称：静态成员与友元班级： 090453 学生姓名：余圣波学号： 09045329 指导教师评定：签名：1、实验目的·学习友元函数的定义和原理。

·学习静态数据成员和静态成员函数的使用。

·学习静态成员代替全局变量实现对象间的共享。

2、实验内容（1）有如下类的定义。

类成员函数copy用于实现两个对象的相互拷贝，请完成该函数的实现。

（有两种方法即不用this 指针和用this指针）成员函数实现：＃include <iostream.h>class Myclass{public:Myclass (int a,int b) { x=a;y=b;}void copy(Myclass & my);void print( ){ cout<<“x=”<<x<<endl;cout<<”y=”<<y<<endl;}private:int x,y;};void Myclass::copy(Myclass & my){x=my.x,y=my.y;}void main(){Myclass my(10,20),t(30,40);my.print( );my. Copy(t);my.print( );}友员函数实现：#include <iostream.h>class Myclass{public:Myclass (int a,int b) { x=a;y=b;}friend void copy(Myclass &o,Myclass y);void print( ){ cout<<"x="<<x<<endl;cout<<"y="<<y<<endl;}private:int x,y;};void copy(Myclass &o,Myclass y){y.x=o.x,y.y=o.y;y.print();cout<<"友元拷贝函数被调用"<<endl;}void main(){cout<<"请输入对象数据："<<endl;int a,b,c,d;cin>>a>>b;Myclass o(a,b);o.print();cout<<"请输入对象数据："<<endl; cin>>c>>d;Myclass y(c,d);y.print();copy(o,y);y.print();}（2）商店经销一种货物，货物成箱购进，成箱卖出，购进和卖出时以重量为单位，各箱的重量不一样，单价不一样，因此商店需要记录下目前库存的货物的总重量和总价值。

c第十四章静态成员与友元

pFirst=pNext; return; } for(Student* pS=pFirst; pS; pS=pS->pNext) if(pS->pNext==this) //找到时,pS指向当前结点的结点 {
pS->pNext=pNext; //pNext即this->pNext return; } }
};
void fn(Student& s1,Student& s2)
{
cout<<s1.noOfStudents; //此处也可以访问静态数据 成员
}
在类的外部，访问静态数据成员的形式可以是 s1.noOfStudents，它等价于s2.noOfStudents，更通常的用 法是Student::noOfStudents(不能用Student.noOfStudents)。 其意义是，静态数据成员是属于Student类的，而不是属 于哪个特定对象的，它也不需要依赖某个特定对象的数 据。
} 函数nsfn()可被认为它声明为void Sc::nsfn(Sc* this,int a) 。对nsfn()的调用，编译像注解的那样进行转换，s的地址 作为第一个传递的参数。 在函数内部，Sc::nsfn()对非静态成员的访问将自动地
把this参数作为指向当前对象的指针。而当Sc::sfn()被调用时 ，没有任何对象的地址被传递。
15.3 静态成员函数
静态成员函数定义是类的内部实现，属于类定义的一 部分。它的定义位置与一般成员函数一样。
与静态数据成员一样，静态成员函数与类相联系，不 与类的对象相联系，所以访问静态成员函数时，不需要对 象。如果用对象去引用静态成员函数，只是用其类型。
例如，下面的程序，两种调用静态成员函数的方法都 是合法的，而且意义一样：

静态成员函数与友元

//lab6_1．cpp
#include;cmath>
using namespace std;
class Rectangle
{ public:
Rectangle(int t=0, int l=0, int d=0, int r=0)
{ top=t; left=l; down=d; right=r; } ~Rectangle() {};
{return a.weight;}
private:
double weight;
};
class Car
{ public:
Car(double w)
{weight=w;
}
friend double totalWeight(Car b)
{return b.weight;}
private: double weight;
实验学时：1学时
其他要求：验证题目和设计题目尽量完成；任选一个设计题目写实验报告
三、实验内容与步骤
说明：对下述实验内容给出实验结果并分析总结。
【验证题目】验证相关例题
【设计题目】
1．设计并测试一个矩形类（Rectangle），属性为矩形的左下与右上角的坐标，矩形水平放置。操作为计算矩形周长与面积。类对象的数据由友元函数来进行访问。并对比友元函数、成员函数和普通函数使用上的不同。参考程序如下：
参考程序如下：
//lab6_2．cpp
#include <iostream>
#include <cmath>
using namespace std;
class Boat
{ public:
Boat(double w)
{ weight=w; }

第5章 静态成员与友元

第五章 静态成员与友元
静态数据的特点：
仅初始化一次。 生命期长。
当我们想设计一个数据，让所有同一类的 对象所共享，我们的解决方法为：
使用全局变量。 ——不建议使用 由于全局变量在所有可见的范围内都可以用， 所以破坏了类的封装性！
使用静态成员。 ——在C++中建议使用 静态成员根据其性质分为静态数据成员和静态 成员函数。
int A::num = 0;
void main()
{
A a;
B b;
cout<<sizeof( a )<<" " << sizeof( b )<< endl;
}
5.1 静态数据成员
对于前例，我们运行进行一下检测： class A { int n; static int num; }; class B { int n; int num; };
5.2 静态成员函数
静态成员函数的使用：
#include <iostream.h>
class C1 { static int n;
public: C1() { }
~C1(){ }
static int fun(){ n++; return n; } };
int C1::n = 0;
void main() { C1 c1, c2; cout<< c1.fun() <<endl; cout<< c2.fun() <<endl; cout<< C1::fun() <<endl;
回顾堆对象的知识：数组对象的生成顺序：按下 标从小到大的顺序构造。
  1. 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。

h(&x);
cout<<"i="<<x.display()<<endl;
return 0;
}
（2）运行结果截图
（3）对程序的分析及注意事项 分析：首先建立一个X类的对象x并且初始化i=1,输出I;然后建立一个Y类对象y,然 后调用y的成员函数g(X*x),使得i=i+1,输出i;然后建立一个Z对象z,调用z的成员函 数f(X*x)，是的i=i+5,输出i;最后调用ቤተ መጻሕፍቲ ባይዱ(X*x),使得i=i+10，输出i; 注意事项：在my_x_y_z.h头文件中，cout,endl不可用。 2.3 Boat and Car （1）源代码
《面向对象程序设计》 上机实验报告
实
实验二 类的静态数据成员和友元
验
名
称
实
1) 掌握友元函数和友元类设计的方法。
2) 学习静态成员的使用，理解静态成员的特殊用途。 验
3) 掌握友元类的定义。 目
4) 学习友元函数及友元类，理解友元类的作用。
的
5) 掌握友元函数和友元类设计的方法。
1）定义一个 Cat 类，拥有静态数据成员 HowManyCats，记录 Cat 的 实
要
实
~cat(){HowManyCats--;}
验
static void GetHowMany()
记
录
{cout<<"Object HowManyCats:"<<HowManyCats<<endl;}
及
个 private:
人
小
static int HowManyCats;
结
};
int cat::HowManyCats=0;
注意事项：当创建一个对象并且使用同类对象初始化时，将不再调用构造函 数而是直接调用复制构造函数，所以在复制构造函数中也要写上HowManyCats++； 反之，将直接调用构造函数而不再调用复制构造函数。
2.2 X,Y,Z类
（1）源代码
#ifndef MY_X_Y_Z_H
class X;
class Y
int i;
};
class Z {
public:
void f(X* x) { x->i += 5; }
};
void h(X* x) { x->i += 10; }
void Y::g(X*x){x->i+=1;} #endif // MY_X_Y_Z_H
# include<my_x_y_z.h>
# include<iostream>
b):"<<endl;
cat::GetHowMany();/*输出HowManyCats的值*/
主
要
实
验
return 0;
记}
录 及 （2）运行结果截图
个
人
小 结
（3）对程序的分析及注意事项 分析：HowManyCats是静态成员数据，首先是输出了HowManyCats的初始值
0，然后创建了一个Cat对象a,从而HowManyCats++,输出HowManyCats的值为1；然后 又创建了一个Cat对象b, HowManyCats++,输出HowManyCats的值为2，然后{},b的生 存周期结束，HowManyCats--，输出HowManyCats为1。
using namespace std;
int main()
{
X x(1);
主
cout<<"i="<<x.display()<<endl;
要
实
Y y;
验
记
y.g(&x);
录
cout<<"i="<<x.display()<<endl;
及
个
Z z;
人
小
z.f(&x);
结
cout<<"i="<<x.display()<<endl;
int main()
{
cout<<"HowManyCats Initial value:"<<endl;
cat::GetHowMany();/*直接通过类名调用函数，输出cat对象个数的初
始值。*/
cat a;/*创建一个cat对象a*/
cout<<"HowManyCats value (after created a):"<<endl;
友元类，其成员函数 f(X*)实现对 X 的成员 i 加 5，函数 h(X*)是 X 的友
元函数，实现对 X 的成员 i 加 10。在一个文件中定义和实现类，在另一 容
个文件中实现 main()函数。
3）定义 Boat 与 Car 两个类，二者都有 weight 属性，定义二者的一
个友元函数 totalWeight()，计算二者的重量和。
{
public:
void g(X*x);
};
class X
主 要
{
实 public:
验
记
X(int ii){i=ii;}
录
及
int display(){return i;}
个
人
friend void h(X*);
小 结
friend void Y::g(X*);
friend class Z;
private:
一、实验内容
2.1 Cat 类
（1）源代码
# include<iostream>
using namespace std;
class cat
{
public:
cat(){HowManyCats++;cout<<"Constructor is called!"<<endl;}
主
cat(cat & p){HowManyCats++;cout<<"Copy is called!"<<endl;}
个体数目；静态成员函数 GetHowMany（），存取 HowManyCats。设计程序
测试这个类，体会静态数据成员和静态成员函数的用法。 验
2）定义类 X、Y、Z，函数 h(X*)，满足：类 X 有私有成员 i，Y 的成
员函数 g(X*)是 X 的友元函数，实现对 X 的成员 i 加 1，类 Z 是类 X 的 内
# include<iostream>
using namespace std;
class Car;
class Boat
主{
要
实 public:
验
记
Boat(int w=0){weight=w;}
cat::GetHowMany();/*输出HowManyCats的值*/
{
cat b;
cout<<"HowManyCats value (after created a and b):"<<endl;
cat::GetHowMany();/*输出HowManyCats的值*/
}
cout<<"HowManyCats value (after created a and and deleted