您的位置: 首页  >  文章  >  第八课 类的封装

第八课 类的封装

分类: 文章 • 2024-11-20 12:22:40

本节主要讲类的类的组合的基本概念、类的封装的基本概念以及类成员作用域的问题，最后实现了一个计算器的运算类。

类的组合

有很多类还可以下分小类，一个大类的由若干个小类组成，大类产生小类称为类的继承。

类的封装

类的封装主要分为两个方面：①类的实现细节②类的使用方式

第八课 类的封装


当使用类时，不需要关心类的具体实现细节，当创建一个类时，才要考虑其内部的实现细节。

基本概念

类的属性：主要通过类中的成员变量来表示的。并不是每一个类的属性都是对外公开的。然后一些类的属性却需要对外公开，这样就需要在类的表示法中定义类的属性和级别。

类的封装：C++中用于表示类的属性的变量成为成员变量，用于表示类的行为的函数称为成员函数。

访问级别：可以给类的属性和类的成员函数定义访问级别。①public：成员变量和成员函数可以在类的内部和外部访问和调用。②private:成员变量和成员函数只能在类的内部访问和调用。

基本例程如下：

[cpp] view plain copy
  1. #include <stdio.h>  
  2.   
  3. struct Computer  
  4. {  
  5.     bool Cpu;  
  6.     bool Neicun;  
  7.     int a();  
  8. };  
  9.   
  10. struct Dell:Computer  
  11. {  
  12. public:  
  13.     bool hp;  
  14.     char Japan;  
  15. private:  
  16.     int b()  
  17.     {  
  18.         printf ("Thist is Dell\n");  
  19.     }  
  20. };  
  21.   
  22. struct Lenovo:Computer  
  23. {  
  24.     bool lenovo;  
  25.     char China;  
  26.     int c()  
  27.     {  
  28.         printf ("L\n");  
  29.         return 0;  
  30.     }  
  31. };  
  32.   
  33.   
  34.   
  35. int main()  
  36. {  
  37.     Dell dell;  
  38.     dell.hp = 1;  
  39.     dell.Japan = 'j';  
  40.     //dell.b(); //无法访问，因为b()成员函数的属性是private  
  41.   
  42.     Lenovo lenovo;  
  43.     lenovo.lenovo = 1;  
  44.     lenovo.c();  
  45.   
  46.     return 0;  
  47. }  
子类中的类成员函数可以访问父类中的类成员函数，如果子类的成员属性是public，同时定义了类的对象，同样可以通过对象来访问。


[cpp] view plain copy
  1. #include <stdio.h>  
  2.   
  3. struct Computer  
  4. {  
  5.     bool Cpu;  
  6.     bool Neicun;  
  7.     int a()  
  8.     {  
  9.         printf ("Computer\n");  
  10.         return 0;  
  11.     }  
  12. };  
  13.   
  14. struct Dell:Computer  
  15. {  
  16. public:  
  17.     bool hp;  
  18.     char Japan;  
  19.     int f()  
  20.     {  
  21.         a();  
  22.         return 0;  
  23.     }  
  24. private:  
  25.     int b()  
  26.     {  
  27.         printf ("Thist is Dell\n");  
  28.     }  
  29. };  
  30.   
  31. struct Lenovo:Computer  
  32. {  
  33.     bool lenovo;  
  34.     char China;  
  35.     int c()  
  36.     {  
  37.         printf ("L\n");  
  38.         a();  
  39.         return 0;  
  40.     }  
  41. };  
  42.   
  43.   
  44.   
  45. int main()  
  46. {  
  47.     Dell dell;  
  48.     dell.hp = 1;  
  49.     dell.Japan = 'j';  
  50.     //dell.b(); //无法访问，因为b()成员函数的属性是private  
  51.     dell.f();  
  52.   
  53.     Lenovo lenovo;  
  54.     lenovo.lenovo = 1;  
  55.     lenovo.c();  
  56.   
  57.     return 0;  
  58. }  
通过上面的程序可以看出，对象访问类中的成员主要由private和public属性来进行控制，同时不同的类之间的类成员的访问也是依靠这两个属性进行控制的，但是如果同一类之间的成员访问时没有限制的。

类成员的作用域

类成员的作用域都只在类的内部，外部无法直接访问，外部可以通过建立类的对象来访问类的成员（也仅仅局限于public属性的成员）。一个类中的成员函数可以直接访问成员变量并调用这个类中的其他成员函数。

类的外部可以通过类变量访问public成员，类成员的作用域与访问级别是没有关系的。

[cpp] view plain copy
  1. #include <stdio.h>  
  2.   
  3. int i = 1;  
  4. struct A  
  5. {  
  6. private:  
  7.     int i;  
  8. public:  
  9.     int j;  
  10.     int a()  
  11.     {  
  12.         i = 3;  
  13.           
  14.         return i;  
  15.     }  
  16. };  
  17.   
  18. int main()  
  19. {  
  20.     int i = 2;  
  21.       
  22.     printf ("i = %d\n",i);  
  23.     printf ("::i = %d\n",::i);  
  24.   
  25.     A a;  
  26.     printf ("a.a() = %d\n", a.a());  
  27.       
  28.     //a.i = 4;  
  29.     //printf ("a.i = %d\n", a.i);  
  30.   
  31.     return 0;  
  32. }  
类成员的作用域只在类的内部，外部无法直接访问，如果外界向访问，需要通过类的对象来进行访问。这里的全局变量i被main函数中的i覆盖，：：i是默认的命名空间，所以是全局的，而在类A中的函数a()属性石public，所以我们可以在main函数中进行访问，而a()使用的变量是类的内部成员变量，所以可以使用，最后的打印结果入下图所示：

第八课 类的封装

struct和class

class是用于定义类的又一个关键字，它的用法和class是完全相同的。struct定义类时候类的默认属性是public，class定义类时类的默认属性石private。需要注意的是：这两个属性都是默认的属性，我们仍然可以使用public和private这两个关键字来进行约束。

[cpp] view plain copy
  1. #include <stdio.h>  
  2.   
  3. int i = 1;  
  4. struct A  
  5. {  
  6. private:  
  7.     int i;  
  8. public:  
  9.     int j;  
  10.     int a()  
  11.     {  
  12.         i = 3;  
  13.           
  14.         return i;  
  15.     }  
  16. };  
  17.   
  18. class B  
  19. {  
  20. private:  
  21.     int a;  
  22. public:  
  23.     int i()  
  24.     {  
  25.         printf ("hello world\n");  
  26.         return 0;  
  27.     }  
  28. };  
  29.   
  30. int main()  
  31. {  
  32.     A a;  
  33.     //a.i;这里的i无法访问，因为属性石private  
  34.   
  35.     B b;  
  36.     b.i(); //这里的成员函数i()可以被访问，因为它的属性是public  
  37.   
  38.     return 1;  
  39. }  

课后练习

要求：

第八课 类的封装

 没有进行类封装的程序如下：

[cpp] view plain copy
  1. #include <stdio.h>  
  2.   
  3. struct Operator  
  4. {  
  5. private:  
  6.     double ob;  
  7.     double oc;  
  8.     char oa;  
  9.   
  10. public:  
  11.     bool setOperator(char a)  
  12.     {  
  13.         bool ret = false;  
  14.   
  15.         if ((a == '+') || (a == '-') || (a == '*') || (a == '/'))  
  16.         {  
  17.             oa = a;  
  18.             ret = true;  
  19.             return ret;  
  20.         }  
  21.         else  
  22.         {  
  23.             ret = false;  
  24.             return ret;  
  25.         }  
  26.     }  
  27.     void setPatameter(double b, double c)  
  28.     {  
  29.         ob = b;  
  30.         oc = c;  
  31.     }  
  32.       
  33.     bool result(double& d)  
  34.     {  
  35.         bool ret = true;  
  36.         switch (oa)  
  37.         {  
  38.             case '/':  
  39.                 {  
  40.                     if ((oc > -0.000001) && (oc < 0.0000001))  
  41.                     {  
  42.                         ret = false;  
  43.                     }  
  44.                     else  
  45.                     {  
  46.                         d = ob / oc;  
  47.                     }  
  48.                     break;  
  49.                 }  
  50.                   
  51.             case '+':  
  52.                 {  
  53.                     d = ob + oc;  
  54.                     break;  
  55.                 }  
  56.                   
  57.             case '*':  
  58.                 {  
  59.                     d = ob * oc;  
  60.   
  61.                     break;  
  62.                 }  
  63.                   
  64.             case '-':  
  65.                 {  
  66.                     d = ob - oc;  
  67.                     break;  
  68.                 }  
  69.             default:  
  70.                     ret = false;  
  71.                 break;  
  72.         }  
  73.         return ret;  
  74.     }     
  75. };  
  76.   
  77. int main()  
  78. {  
  79.     double aa = 0;  
  80.   
  81.     Operator o;  
  82.     o.setOperator('/');  
  83.     o.setPatameter(2,0);  
  84.     o.result(aa);  
  85.   
  86.     printf ("%f\n",aa);  
  87.   
  88.     return 1;  
  89. }  
进行类封装之后的程序：

main.cpp

[cpp] view plain copy
  1. #include <stdio.h>  
  2. #include "o.h"  
  3.   
  4. int main()  
  5. {  
  6.     double aa = 0;  
  7.   
  8.     Operator o;  
  9.     o.setOperator('/');  
  10.     o.setPatameter(2,0);  
  11.     o.result(aa);  
  12.   
  13.     printf ("%f\n",aa);  
  14.   
  15.     return 1;  
  16. }  
o.cpp

[cpp] view plain copy
  1. #include "o.h"  
  2.   
  3. bool Operator::setOperator(char a) //这里需要指明setOperator是哪个类的函数，要不然setOperator将会成为全局函数  
  4.                                    //这里的表示方法是使用：：  
  5. {  
  6.     bool ret = false;  
  7.   
  8.     if ((a == '+') || (a == '-') || (a == '*') || (a == '/'))  
  9.     {  
  10.         oa = a;  
  11.         ret = true;  
  12.         return ret;  
  13.     }  
  14.     else  
  15.     {  
  16.         ret = false;  
  17.         return ret;  
  18.     }  
  19. }  
  20. void Operator::setPatameter(double b, double c)  
  21. {  
  22.     ob = b;  
  23.     oc = c;  
  24. }  
  25.   
  26. bool Operator::result(double& d)   
  27. {  
  28.     bool ret = true;  
  29.     switch (oa)  
  30.     {  
  31.         case '/':  
  32.             {  
  33.                 if ((oc > -0.000001) && (oc < 0.0000001))  
  34.                 {  
  35.                     ret = false;  
  36.                 }  
  37.                 else  
  38.                 {  
  39.                     d = ob / oc;  
  40.                 }  
  41.                 break;  
  42.             }  
  43.               
  44.         case '+':  
  45.             {  
  46.                 d = ob + oc;  
  47.                 break;  
  48.             }  
  49.               
  50.         case '*':  
  51.             {  
  52.                 d = ob * oc;  
  53.                 break;  
  54.             }  
  55.               
  56.         case '-':  
  57.             {  
  58.                 d = ob - oc;  
  59.                 break;  
  60.             }  
  61.         default:  
  62.                 ret = false;  
  63.             break;  
  64.     }  
  65.     return ret;  
  66. }     
o.h

[cpp] view plain copy
  1. #ifndef _O_H  
  2. #define _O_H  
  3.   
  4. struct Operator  
  5. {  
  6. private:  
  7.     double ob;  
  8.     double oc;  
  9.     char oa;  
  10.   
  11. public:  
  12.     bool setOperator(char a);  
  13.     void setPatameter(double b, double c);  
  14.     bool result(double& d);  
  15.       
  16. };  
  17. #endif  

相关推荐