devbox
数据灵魂
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C语言实现面向对象编程 | 干货_c语言对象编程

作者：数据灵魂 | 2024-01-29 16:02:49

赞

踩

c语言对象编程

前言

        GOF的《设计模式》一书的副标题叫做“可复用面向对象软件的基础”，从标题就能看出面向对象是设计模式基本思想。

由于C语言并不是面向对象的语言，C语言没有直接提供封装、继承、组合、多态等面向对象的功能，但C语言有struct和函数指针。我们可以用struct中的数据和函数指针，以此来模拟对象和类的行为。

所以在正式开始设计模式前，先看看如何用C语言实现面向对象编程。

本章针对面向对象的封装、继承、组合、多态给出C语言的实现方法。

封装

        封装是指对象仅暴露必要的对外接口（这里指public方法）来和其它对象进行交互，其它的属性和行为都无需暴露，这使得对象的内部实现可以自由修改。

这也要求对象包含它能进行操作所需要的所有信息，不必依赖其它对象来完成自己的操作。

以下以电力公司的例子演示封装。

电力公司生产并提供电力。为了汇聚各种发电厂的电力并让用户获得电力，电力公司提供了两个统一接口：

1、电力公司汇聚各种发电厂的电力，无论是火力发电厂、水力发电厂、原子能发电厂等都使用一个接口。如果什么时候一家火力发电厂改造成了风力发电厂，发电厂的实现完全不一样了，但接口不变，所以电力公司感觉不到发电厂变了，不需要为了发电厂实现升级而改造电力公司的系统。

2、电力公司向用户提供电力，无论用户用电的设备是烤面包机还是洗衣机，电力公司和用户之间都使用一个接口（电源插座）。用户的用电设备可以千变万化，但接口（电源插座）不变。所以电力公司不用关系用户的什么设备在用电。

代码：

  1. #include <stdio.h>
  2.  
  3. struct PowerCompany {
  4.     int powerReserve;
  5.     void (*PowerPlant)(struct PowerCompany *this, int power);
  6.     void (*PowerUser)(struct PowerCompany *this, int power);
  7. };
  8.  
  9.  
  10. void PowerPlant(struct PowerCompany *this, int power)
  11. { 
  12.     this->powerReserve += power;
  13.     printf("默认发电厂，发电%d瓦\n", power); 
  14.     return;  
  15. }
  16.  
  17. void PowerUser(struct PowerCompany *this, int power)
  18. {
  19.     if (this->powerReserve >= power) {
  20.         printf("用电%d瓦\n", power);
  21.         this->powerReserve -= power;
  22.     } else {
  23.         printf("电力不足，用电失败\n");
  24.     }
  25.     return;
  26. }
  27.  
  28. /* struct PowerCompany 的构造函数 */
  29. void PowerCompany(struct PowerCompany *this)
  30. {
  31.     this->powerReserve = 0;
  32.     this->PowerPlant = PowerPlant;
  33.     this->PowerUser = PowerUser;
  34.     return;
  35. }
  36.  
  37. /* struct PowerCompany 的析构函数 */
  38. void _PowerCompany(struct PowerCompany *this)
  39. {
  40.  
  41. }
  42.  
  43. int main(void)
  44. {
  45.     struct PowerCompany myPowerCompany;
  46.     PowerCompany(&myPowerCompany);
  47.  
  48.     /* 发电 */
  49.     myPowerCompany.PowerPlant(&myPowerCompany, 1000);
  50.  
  51.     /* 用电 */
  52.     myPowerCompany.PowerUser(&myPowerCompany, 800);
  53.     myPowerCompany.PowerUser(&myPowerCompany, 800);
  54.     
  55.     _PowerCompany(&myPowerCompany);
  56.     return 0;
  57. }

从电力公司的例子中可以看出，良好的封装可以有效减少耦合性，封装内部实现可以自由修改，对系统的其它部分没有影响。

继承

        面向对象编程最强大的功能之一就是代码重用，而继承就是实现代码重用的主要手段之一。继承允许一个类继承另一个类的属性和方法。

我们可以通过识别事物之间的共性，通过抽象公共属性和行为来构造父类，而通过继承父类来构造各子类。父类，即公共属性和行为，就得到了复用。

以下哺乳动物的例子演示继承。

猫和狗都是哺乳动物，它们具有公共的属性和行为。比如，猫和狗都有眼睛，且它们都会叫。

我们把眼睛的颜色、会叫抽象出来，作为哺乳动物父类的属性，让猫类、狗类都继承哺乳动物父类，可实现对”眼睛的颜色“、”会叫“实现的复用。

UML：

代码：

  1. #include <stdio.h>
  2.  
  3. struct Mammal {
  4.     int eyeColor;
  5.     void (*ShowEyeColor)(struct Mammal *this);
  6.     int callNum;
  7.     void (*Call)(struct Mammal *this);
  8. };
  9.  
  10. void ShowEyeColor(struct Mammal *this)
  11. {
  12.     if (this->eyeColor == 1) {
  13.         printf("眼睛是绿色\n");
  14.     } else {    
  15.         printf("眼睛是蓝色\n");
  16.     }
  17.     return;
  18. }
  19.  
  20. void Call(struct Mammal *this)
  21. {
  22.     printf("叫%d声\n", this->callNum);
  23.     return;
  24. }
  25.  
  26. // struct Mammal 的构造函数
  27. void Mammal(struct Mammal *this, int eyeColor, int callNum)
  28. {
  29.     this->eyeColor = eyeColor;    
  30.     this->ShowEyeColor = ShowEyeColor;  
  31.     this->callNum = callNum;
  32.     this->Call = Call;
  33.     return;  
  34. }
  35.  
  36. struct Dog {
  37.     struct Mammal mammal;
  38. };
  39.  
  40. // struct Dog 的构造函数
  41. void Dog(struct Dog *this, int eyeColor, int callNum)
  42. {
  43.     Mammal(this, eyeColor, callNum);
  44.     // 狗类的其它属性，略
  45.     return;
  46. }
  47.  
  48. // struct Dog 的析构函数
  49. void  _Dog(struct Dog *this)
  50. {
  51.  
  52. }
  53.  
  54. struct Cat {
  55.     struct Mammal mammal;
  56.     // 猫类的其它属性，略
  57. };
  58.  
  59. // struct Cat 的构造函数
  60. void Cat(struct Cat *this, int eyeColor, int callNum)
  61. {
  62.     Mammal(this, eyeColor, callNum);
  63.     return;
  64. }
  65.  
  66. // struct Cat 的析构函数
  67. void  _Cat(struct Cat *this)
  68. {
  69.  
  70. }
  71.  
  72. int main(void)
  73. {
  74.     struct Dog myDog;
  75.     Dog(&myDog, 1, 3);
  76.     myDog.mammal.ShowEyeColor(&myDog);
  77.     myDog.mammal.Call(&myDog);
  78.     _Dog(&myDog);
  79.  
  80.     struct Cat myCat;
  81.     Cat(&myCat, 2, 5);
  82.     myCat.mammal.ShowEyeColor(&myCat);
  83.     myCat.mammal.Call(&myCat);
  84.     _Cat(&myCat); 
  85.     
  86.     return 0;
  87. }

多态

        多态与继承是紧耦合的关系，但它通常作为面向对象技术中最强大的优点之一。

子类从继承父类的接口，每个子类是单独的实体，每个子类需要对同一消息有单独的应答。

每个子类对同一消息的应答采用继承的相同接口，但每个子类可以有不同的实现，这就是多态。

在猫和狗的例子中，猫类、狗类都继承了哺乳动物父类的“叫”的方法，但猫类、狗类的叫声并不一样，所以猫类、狗类可以采用不同的“叫”的实现。

以下代码演示了多态。

代码：

  1. #include <stdio.h>
  2.  
  3. struct Mammal {
  4.     int eyeColor;
  5.     void (*ShowEyeColor)(struct Mammal *this);
  6.     int callNum;
  7.     void (*Call)(struct Mammal *this);
  8. };
  9.  
  10. void ShowEyeColor(struct Mammal *this)
  11. {
  12.     if (this->eyeColor == 1) {
  13.         printf("眼睛是绿色\n");
  14.     } else {    
  15.         printf("眼睛是蓝色\n");
  16.     }
  17.     return;
  18. }
  19.  
  20. void Call(struct Mammal *this)
  21. {
  22.     printf("叫%d声\n", this->callNum);
  23.     return;
  24. }
  25.  
  26. /* struct Mammal 的构造函数 */
  27. void Mammal(struct Mammal *this, int eyeColor, int callNum)
  28. {
  29.     this->eyeColor = eyeColor;    
  30.     this->ShowEyeColor = ShowEyeColor;  
  31.     this->callNum = callNum;
  32.     this->Call = Call;
  33.     return;  
  34. }
  35.  
  36. struct Dog {
  37.     struct Mammal mammal;
  38. };
  39.  
  40. void Bark(struct Dog *this)
  41. {
  42.     int i;
  43.     for (i = 0; i < this->mammal.callNum; i++) {
  44.         printf("汪 ");
  45.     }
  46.     printf("\n");
  47.     return;
  48. }
  49.  
  50. /* struct Dog 的构造函数 */
  51. void Dog(struct Dog *this, int eyeColor, int callNum)
  52. {
  53.     Mammal(this, eyeColor, callNum);
  54.     this->mammal.Call = Bark;
  55.     return;
  56. }
  57.  
  58. // struct Dog 的析构函数
  59. void  _Dog(struct Dog *this)
  60. {
  61.  
  62. }
  63.  
  64. struct Cat {
  65.     struct Mammal mammal;
  66. };
  67.  
  68. void Meow(struct Cat *this)
  69. {
  70.     int i;
  71.     for (i = 0; i < this->mammal.callNum; i++) {
  72.         printf("喵 ");
  73.     }
  74.     printf("\n");
  75.     return;
  76. }
  77.  
  78. /* struct Cat 的构造函数 */
  79. void Cat(struct Cat *this, int eyeColor, int callNum)
  80. {
  81.     Mammal(this, eyeColor, callNum);
  82.     this->mammal.Call = Meow;
  83.     return;
  84. }
  85.  
  86. // struct Cat 的析构函数
  87. void  _Cat(struct Cat *this)
  88. {
  89.  
  90. }
  91.  
  92. int main(void)
  93. {
  94.     struct Dog myDog;
  95.     Dog(&myDog, 1, 3);
  96.     
  97.     struct Cat myCat;
  98.     Cat(&myCat, 2, 5);
  99.  
  100.     struct Mammal *myMammal;
  101.     myMammal = &myDog;
  102.     myMammal->Call(myMammal);
  103.     myMammal = &myCat;
  104.     myMammal->Call(myMammal);
  105.  
  106.     _Dog(&myDog);
  107.     _Cat(&myCat);
  108.  
  109.     return 0;
  110. }

组合

        组合与继承都是面向对象中代码复用的方式，也只有通过组合和继承两种方式能够实现使用其他类构建新类。

在前面讲的继承关系中，我们把通用属性和行为抽象出来作为父类。

例如：猫、狗都是哺乳动物，它们具有哺乳动物通用的属性和行为。猫、狗与哺乳动物的关系是“is-a”，即猫、狗（is-a）哺乳动物。而组合关系体现的是“has-a”。以房子和窗户的关系举例。

我们可以单独构建窗户类，然后把窗户类应用到各种房子类上。此时房子（has-a）窗户，但绝不是窗户（is-a）房子。

以下UML和代码演示了组合。

UML：

代码

  1. #include <stdio.h>
  2.  
  3. struct Window {
  4.     int length;
  5.     int width;
  6.     void (*ShowWindow)(struct Window *this);
  7. };
  8.  
  9. void ShowWindow(struct Window *this)
  10. {
  11.     printf("这是长%d厘米、宽%d厘米的窗户\n", this->length, this->width);
  12.     return;
  13. }
  14.  
  15. void Window(struct Window *this, int length, int width)
  16. {
  17.     this->length = length;
  18.     this->width = width;
  19.     this->ShowWindow = ShowWindow;
  20.     return;
  21. }
  22.  
  23. void _Window(struct Window *this)
  24. {
  25.  
  26. }
  27.  
  28. struct House {
  29.     struct Window *window;
  30.     int livingRoomNum;
  31.     int bedRoomNum;
  32.     int bathRoomNum;
  33.     void (*ShowHouse)(struct House *this);
  34. };
  35.  
  36. void ShowHouse(struct House *this)
  37. {
  38.     printf("这是%d室%d厅%d卫的房子\n", this->bedRoomNum, this->livingRoomNum, this->bathRoomNum);
  39.     return;
  40. }
  41.  
  42.  
  43. void House(struct House *this, int livingRoomNum, int bedRoomNum, int bathRoomNum)
  44. {
  45.     this->livingRoomNum = livingRoomNum;
  46.     this->bedRoomNum = bedRoomNum;
  47.     this->bathRoomNum = bathRoomNum;
  48.     this->ShowHouse = ShowHouse;
  49.     return;
  50. }
  51.  
  52. void _House(struct House *this)
  53. {
  54.  
  55. }
  56.  
  57. void main()
  58. {
  59.     struct House myHouse;
  60.     House(&myHouse, 2, 3, 2);
  61.     
  62.     /* 组合是一种低耦合，如果不初始化，子类只是存放了一个空指针来占位关联。
  63.        此处是与继承关系的区别。继承是一种强耦合，在继承关系中，无论如何子类拥有父类全部的信息。*/
  64.     struct Window myWindow1;
  65.     myHouse.window = &myWindow1;
  66.     Window(myHouse.window, 100, 50);
  67.  
  68.     /* 通过获得其它对象的引用而在“运行时”动态定义 */
  69.     myHouse.ShowHouse(&myHouse);
  70.     myHouse.window->ShowWindow(myHouse.window);
  71.  
  72.     _Window();
  73.     _House();
  74.  
  75.     return;
  76. }

组合和继承的区别有以下几点：

组合关系体现的是“has-a”。继承关系体现的是“is-a”。

温馨提示

        由于微信公众号近期改变了推送规则，如果您想经常看到我们的文章，可以在每次阅读后，在页面下方点一个「赞」或「在看」，这样每次推送的文章才会第一时间出现在您的订阅列表里。

声明：本文内容由网友自发贡献，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：【wpsshop博客】
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号