实验四,静态成员与友元

一、实验目的和要求

    了解成员函数的特性,掌握静态成员、友元等概念。

二、实验内容

1、调试下列程序,写出输出结果,并分析输出结果。

  1. //sy4_1.cpp
  2. #include<iostream>
  3. using namespace std;
  4. class My
  5. {
  6. public:
  7. My( int aa)
  8. {
  9. A=aa;
  10. B-=aa;
  11. }
  12. static void fun(My m);
  13. private:
  14. int A;
  15. static int B;
  16. };
  17. void My::fun(My m)
  18. {
  19. cout<< "A="<<m.A<< endl;
  20. cout<< "B="<<B<< endl;
  21. }
  22. int My::B= 100;
  23. int main()
  24. {
  25. My P(6),Q(8);
  26. My::fun(P);
  27. Q.fun(Q);
  28. return 0;
  29. }
输出结果:

输出结果分析:创建对象P时,调用构造函数对其初始化得到A=6,B=B-A=100-6=94,再创建对象Q时,调用构造函数对其初始化得到,A=8,B=B-A=94-8=86,最后调用了静态成员函数static void fun(),又因为B是静态数据成员,所以输出此结果。

2、分析并调试程序,完成下列问题。

  1. //sy4_2.cpp
  2. #include<iostream>
  3. #include<cmath>
  4. using namespace std;
  5. class My
  6. {
  7. public:
  8. My( double i= 0){x=y=i;}
  9. My( double i, double j){x=i;y=j;}
  10. My(My&m){x=m.x;y=m.y;}
  11. friend double dist(My&a,My&b);
  12. private:
  13. double x,y;
  14. };
  15. double dist(My&a,My&b)
  16. {
  17. double dx=a.x-b.x;
  18. double dy=a.y-b.y;
  19. return sqrt(dx*dx+dy*dy);
  20. }
  21. int main()
  22. {
  23. My m1,m2( 15),m3( 13, 14);
  24. My m4(m3);
  25. cout<< "The distance1:"<<dist(m1,m3)<< endl;
  26. cout<< "The distance2:"<<dist(m2,m3)<< endl;
  27. cout<< "The distance3:"<<dist(m3,m4)<< endl;
  28. cout<< "The distance4:"<<dist(m1,m2)<< endl;
  29. return 0;
  30. }

(1)指出所有的构造函数,它们在本程序中分别起什么作用?

        构造函数My(double i=0)用来对m1,m2进行初始化,My(double i,double j)对m3进行初始化,拷贝构造函数My(My&m)用来对m4进行初始化。

(2)指出设置默认参数的构造函数。

        My(double i=0)为带默认参数的构造函数。

(3)指出友元函数。将友元函数放到私有部分,观察结果是否有变化。

       dist()为友元函数,将其放到私有部分,编译仍是正确的的,因为友元函数声明时仍与普通函数一致的,所以编译时不会出错。

(4)写出输出结果,并分析输出结果。


3、定义一个Student类,在该类定义中包括一个数据成员score(分数)、两个静态数据成员total(总分)和学生人数count;成员函数scoretotalcount(float s)用于设置分数、求总分和累计学生人数;静态成员函数sum()用于返回总分;静态成员函数average()用于求平均值。在main()函数中,输入某班同学的成绩,并调用上述函数求全班学生的总分和平均分。

  1. #include<iostream>
  2. using namespace std;
  3. class student
  4. {
  5. public:
  6. void scoretotalcount(float s);
  7. static float sum();
  8. static float average();
  9. private:
  10. float score;
  11. static float total;
  12. static int count;
  13. };
  14. float student::total= 0;
  15. int student::count= 0;
  16. void student::scoretotalcount( float s)
  17. {
  18. score=s;
  19. total+=score;
  20. count++;
  21. }
  22. float student::sum(){ return total;}
  23. float student::average(){ return total/count;}
  24. int main()
  25. {
  26. float s;
  27. int n;
  28. student a[ 10];
  29. cout<< "输入学生个数:";
  30. cin>>n;
  31. cout<< "输入学生成绩:";
  32. for( int i( 0);i<n;i++)
  33. {
  34. cin>>s;
  35. a[i].scoretotalcount(s);
  36. }
  37. cout<< "班级总分为:";
  38. cout<<student::sum()<< endl;
  39. cout<< "班级平均分为:";
  40. cout<<student::average()<< endl;
  41. return 0;
  42. }

运行结果:


4、声明Book与Ruler两个类,二者都有weight属性,定义二者的一个友元函数totalWeight(),计算二者的重量和。

  1. #include<iostream>
  2. using namespace std;
  3. class Ruler;
  4. class Book
  5. {
  6. public:
  7. Book( int i= 0){weight=i;}
  8. friend float totalWeight(Book&m,Ruler&n);
  9. private:
  10. float weight;
  11. };
  12. class Ruler
  13. {
  14. public:
  15. Ruler( int j= 0){weight=j;}
  16. friend float totalWeight(Book&m,Ruler&n);
  17. private:
  18. float weight;
  19. };
  20. float totalWeight(Book&m,Ruler&n)
  21. { return m.weight+n.weight;}
  22. int main()
  23. {
  24. int i,j;
  25. cout<< "Book weight:";
  26. cin>>i;
  27. cout<< "Ruler weight:";
  28. cin>>j;
  29. Book B(i);
  30. Ruler R(j);
  31. cout<< "totalweight"<<totalWeight(B,R)<< endl;
  32. return 0;
  33. }

运行结果:


三、分析与讨论

1、如何定义静态数据成员和成员函数?

    答:静态数据成员不属于任何对象,它不因对象的建立而产生,也不因对象的析构而删除,它是类定义的一部分,所以使用静态数据成员不会破坏类的隐蔽性。类中的静态数据成员不同于一般的静态变量,也不同于其他类数据成员。它在程序开始运行时创建而不是在对象创建时创建。它所占空间的回收也不是在析构函数时进行而是在程序结束时进行。

    成员函数用来描述对象的行为,与普通函数一样,它可以重载,可以使用默认参数,还可以声明为内联函数。

2、如何对静态数据成员初始化?

    答:静态数据成员的初始化与一般数据成员不同,它的初始化不能在构造函数中进行。静态数据成员初始化的格式为:<数据类型><类名>::<静态数据成员>=<初始值>;   这里的作用域运算符“::”用来说明静态数据成员所属类。

3、静态成员函数访问静态成员与非静态成员有何区别?

    答:C++中静态成员函数是不能访问非静态成员的,但反过来就可以。
因为静态成员是属于类的,它可以在类对象没有被初始化时就访问,而非静态成员则必须要在类对象初始化后才会被创建并初始化,所以在C++中静态函数不能访问非静态成员。

4、如何调用静态成员函数?

    答:调用静态成员函数的格式为:  <类名>::<静态成员函数名>(<参数表>)或<对象名>::<静态成员函数名>(<参数表>)  静态成员函数的主要作用是用来访问同类中的静态成员,维护对象之间共享的对象数。

5、如何理解“静态成员不是属于某个对象的,而是属于类的所有对象的。”这句话?

    答:静态成员是指声明为static的类成员,包括静态数据成员和静态成员函数,在类的范围内所有对象共享该数据。

6、比较友元函数与一般函数在定义和调用方面的异同。

    答:放在类体外定义的函数是一般函数;在类里声明一个普通函数,加上关键字friend,就成了该类的友元函数,它可以访问该类的一切成员。调用友元函数的方式与普通函数的实现完全一样。一个普通的函数可以定义为类的友元函数,一个类的成员函数也可以定义成另一个类的友元函数。

四、实验小结

        通过本次实验我们了解了成员函数的特性,知道了静态成员、友元等概念。在程序的调试过程中也在不断的发现问题并解决问题,总之学到了很多。


猜你喜欢

转载自blog.csdn.net/jyf1182813178/article/details/80844261