程序博客网 > 宁夏广播电视网络缴费

第八课 类的封装

来源：互联网 发布：宁夏广播电视网络缴费 编辑：程序博客网 时间：2024/05/22 00:49

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

类的组合

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

类的封装

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



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

基本概念

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

类的封装：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  
阅读全文
0 0
宁夏广播电视网络缴费 宁夏广播电视网络缴费
原创粉丝点击
热门IT博客
欠淘宝贷款50万逾期2年欠淘宝贷款50万逾期2年
淘宝怎么买凤楼信息淘宝怎么买凤楼信息
网络怎么交电费
黔程金融网络贷款
淘宝哪家是正品漫步者
细说php哪里可以下载
python os.exec 参数
大家的幻想乡脚本源码
权限 角色 数据库设计
安卓sqlite数据库查询
开淘宝店用什么笔记本
人工智能 饭碗
苹果手机格式化后如何恢复数据
java项目管理系统
淘宝违规扣分在哪里看
手机vpn网络负面影响
网络校时手表
qq软件分享群号码
在linux里安装虚拟机
数据库查询语句select
热门问题 老师的惩罚 人脸识别 我在镇武司摸鱼那些年 重生之率土为王 我在大康的咸鱼生活 盘龙之生命进化 天生仙种 凡人之先天五行 春回大明朝 姑娘不必设防，我是瞎子 竹竿大棚 一根竹竿 一支竹竿哟 竹竿诗经 诗经 竹竿 毛竹竿价格 竹竿何袅袅 竹竿镇 试垂竹竿钓 竹竿捅飞机 一竹竿打到底 竹竿批发市场 里弄里杠竹竿的歇后语 竹竿舞基本步法图解 竹竿舞是哪个民族的 竹竿舞基本跳法 竹竿批发价格 一根竹竿容易弯 里弄里扛竹竿 猴子爬竹竿歇后语 竹笆 竹笋做法 竹笋炒肉 山竹笋 竹笋图片 竹笋功效 竹笋怎么吃 清炒竹笋 炒竹笋 孕妇吃竹笋 方竹笋 竹笋干 竹笋炖排骨 竹笋拼音 鲜竹笋炒肉 鲜竹笋 竹笋简笔画 竹笋虫 竹笋型 红烧竹笋 竹笋的功效

程序博客网，程序员的互联网技术博客家园。csdn论坛精品 msdn技术资料都在这里