[VIP专享]C语言下的封装 继承 与多态
c#第6章 继承与多态性
例如： 例如： class Humen { public string name; name; public string sex; sex; public string work ; } class Teacher:Humen Teacher: { public string speciality ; public string department; department; } Human是基类 Teacher是派生类 Human是基类，Teacher是派生类，它拥有基类 是基类， 是派生类， 的全部成员。 的全部成员。
派生类隐藏基类成员 ：用new关键字。 new关键字 关键字。 隐藏基类的字段成员： 隐藏基类的字段成员： 派生类可以声明与基类有相同的名称和类型的字 派生类可以声明与基类有相同的名称和类型的字 段成员来隐藏基类的字段。 来隐藏基类的字段 段成员来隐藏基类的字段。这时通过派生类引用 或对象访问的是派生类的字段， 或对象访问的是派生类的字段，基类的相应成员 被屏蔽了。但是通过指向派生类对象的基类引用 被屏蔽了。但是通过指向派生类对象的基类引用 访问的则是基类的字段。 访问的则是基类的字段。 隐藏基类的方法成员： 隐藏基类的方法成员： 派生类可以声明与基类有相同的方法名称和形参 表的方法成员来隐藏基类的方法 基类的方法， 表的方法成员来隐藏基类的方法，与返回类型无 这时通过派生类引用或对象访问的是派生类 关。这时通过派生类引用或对象访问的是派生类 的方法成员，基类的相应方法成员被屏蔽了。 的方法成员，基类的相应方法成员被屏蔽了。但 是通过指向派生类对象的基类引用访问的则是基 指向派生类对象的基类引用访问的则是 是通过指向派生类对象的基类引用访问的则是基 类的成员。 类的成员。 派生类中可以通过 可以通过base关键字访问被隐藏的基 在派生类中可以通过base关键字访问被隐藏的基 类成员。 类成员。 详见例MaskBase。 详见例MaskBase。
C++中的封装、继承、多态理解
C++中的封装、继承、多态理解封装(encapsulation)：就是将抽象得到的数据和⾏为(或功能)相结合，形成⼀个有机的整体，也就是将数据与操作数据的源代码进⾏有机的结合，形成”类”，其中数据和函数都是类的成员。
封装的⽬的是增强安全性和简化编程，使⽤者不必了解具体的实现细节，⽽只是要通过外部接⼝，特定的访问权限来使⽤类的成员。
封装可以隐藏实现细节，使得代码模块化。
继承(inheritance)：C++通过类派⽣机制来⽀持继承。
被继承的类型称为基类或超类，新产⽣的类为派⽣类或⼦类。
保持已有类的特性⽽构造新类的过程称为继承。
在已有类的基础上新增⾃⼰的特性⽽产⽣新类的过程称为派⽣。
继承和派⽣的⽬的是保持已有类的特性并构造新类。
继承的⽬的：实现代码重⽤。
派⽣的⽬的：实现代码扩充。
三种继承⽅式：public、protected、private。
继承时的构造函数：(1)、基类的构造函数不能被继承，派⽣类中需要声明⾃⼰的构造函数；(2)、声明构造函数时，只需要对本类中新增成员进⾏初始化，对继承来的基类成员的初始化，⾃动调⽤基类构造函数完成；(3)、派⽣类的构造函数需要给基类的构造函数传递参数；(4)、单⼀继承时的构造函数：派⽣类名::派⽣类名(基类所需的形参，本类成员所需的形参):基类名(参数表) {本类成员初始化赋值语句；}；(5)、当基类中声明有默认形式的构造函数或未声明构造函数时，派⽣类构造函数可以不向基类构造函数传递参数；(6)、若基类中未声明构造函数，派⽣类中也可以不声明，全采⽤缺省形式构造函数；(7)、当基类声明有带形参的构造函数时，派⽣类也应声明带形参的构造函数，并将参数传递给基类构造函数；(8)、构造函数的调⽤次序：A、调⽤基类构造函数，调⽤顺序按照它们被继承时声明的顺序(从左向右)；B、调⽤成员对象的构造函数，调⽤顺序按照它们在类中的声明的顺序；C、派⽣类的构造函数体中的内容。
继承时的析构函数：(1)、析构函数也不被继承，派⽣类⾃⾏声明；(2)、声明⽅法与⼀般(⽆继承关系时)类的析构函数相同；(3)、不需要显⽰地调⽤基类的析构函数，系统会⾃动隐式调⽤；(4)、析构函数的调⽤次序与构造函数相反。
c语言三种继承方式
c语言三种继承方式C语言中的继承方式有三种，分别是单继承、多继承和多重继承。
1. 单继承在C语言中，单继承是指一个类只能继承自一个父类。
通过单继承，子类可以继承父类的成员变量和成员函数，并且可以在子类中对这些成员进行重写或扩展。
这种继承方式可以实现代码的重用和扩展，提高了代码的可维护性和可读性。
2. 多继承多继承是指一个类可以同时继承自多个父类。
通过多继承，子类可以继承多个父类的成员变量和成员函数。
在C语言中，可以通过结构体来实现多继承的效果。
子类可以通过结构体嵌套的方式，将多个父类的成员变量和成员函数组合在一起，从而实现多继承的效果。
多继承可以在一定程度上提高代码的复用性，但也增加了代码的复杂性和理解难度。
3. 多重继承多重继承是指一个类同时继承自多个父类，并且这些父类之间存在继承关系。
通过多重继承，子类可以继承多个父类的成员变量和成员函数，并且可以通过继承链的方式，依次调用父类的成员函数。
在C语言中，可以通过结构体嵌套的方式来实现多重继承。
多重继承可以实现更复杂的代码结构，但也增加了代码的复杂性和维护难度。
继承是面向对象编程中的重要概念，通过继承可以实现代码的重用和扩展。
在C语言中，可以通过结构体嵌套的方式来模拟继承的效果。
通过继承，可以将相关的代码组织在一起，提高代码的可读性和可维护性。
在实际的程序设计中，选择何种继承方式应根据具体的需求和设计考虑。
单继承适用于简单的继承关系，多继承适用于需要同时继承多个父类的情况，多重继承适用于父类之间存在继承关系的情况。
不同的继承方式在代码结构和功能实现上有所不同，需要根据实际情况进行选择。
在使用继承时，需要注意继承关系的合理性和代码的可维护性。
继承关系应符合面向对象编程的设计原则，避免出现过于复杂的继承链和多重继承导致的代码混乱。
同时，需要注意在子类中对父类成员的访问权限控制，避免破坏封装性和安全性。
C语言中的继承方式包括单继承、多继承和多重继承。
通过继承，可以实现代码的重用和扩展，提高代码的可维护性和可读性。
面向对象的三大特性(封装-继承-多态)
一丶封装1 权限修饰符可以用来修饰成员变量和成员方法，对于类的权限修饰只可以用public和缺省default。
被public修饰的类可以在任意地方被访问；default类只可以被同一个包内部的类访问。
权限由大到小：public protected default(不写) private被private修饰的成员只能在本类中访问，外界不能访问2 set()/get()方法（1）this关键字a.可以用来调用变量，方法，构造方法；b.this.xx 理解为调用当前类的xx。
（2）成员变量和局部变量1）在类中的位置不同a:成员变量:在类中,方法外b:局部变量:在方法声明上（形式参数）,或者是在方法定义中2）在内存中的位置不同a:成员变量:在堆内存b:局部变量:在栈内存3）生命周期不同a:成员变量:随着对象的创建而存在,随着对象的消失而消失b:局部变量:随着方法调用而存在,随着方法的调用结束而消失4）初始化值不同a:成员变量:有默认值b:局部变量:必须初始化值,否则报错!(在使用它之前,没有初始化) （3）set()/get()方法当成员变量被private修饰时，不在本类中无法直接访问，便需要set()/get()方法来解决这个问题3 封装性封装：是面向对象的第一大特性，所谓封装，就是值对外部不可见（一般而言被private修饰），外部只能通过对象提供的接口（如set()/get()方法）来访问。
封装的好处：a.良好的封装能够减少耦合；b.类内部的结构可以自己修改，对外部影响不大；c.可以对成员进行更精准的控制（防止出现与事实不符的情况）；d.影藏实现细节。
注意：在开发中，类的成员变量全部要进行封装，封装之后通过set()/get()方法访问。
二丶继承extends1 实现：通过 class Zi extends Fu{} 实现类的继承（1）子类继承父类，父类中声明的属性，方法，子类都可以获取到；当父类中有私有的属性方法时，子类同样可以获取到，由于封装性的设计，使得子类不能直接调用访问。
封装、继承和多态的概念
封装、继承和多态的概念
封装、继承和多态是面向对象编程中的三个重要概念，下面分别进行详细解释：
一、封装
封装是指将对象的属性和方法封装在一起，形成一个独立的单元，对外部隐藏对象的实现细节，只暴露必要的接口供外部使用。
封装可以有效地保护对象的数据和行为，避免外部的误操作和非法访问，提高了代码的安全性和可维护性。
在面向对象编程中，封装是实现信息隐藏和数据保护的重要手段。
二、继承
继承是指一个类可以从另一个类中继承属性和方法，从而可以重用已有的代码和功能。
继承是面向对象编程中实现代码复用的重要手段，可以减少代码的重复性，提高代码的可读性和可维护性。
继承可以分为单继承和多继承两种方式，单继承是指一个类只能从一个父类中继承，而多继承是指一个类可以从多个父类中继承属性和方法。
三、多态
多态是指同一个方法在不同的对象上可以有不同的行为，即同一个方法可以有多
种不同的实现方式。
多态是面向对象编程中的重要概念，可以提高代码的灵活性和可扩展性。
多态可以分为编译时多态和运行时多态两种方式，编译时多态是指方法的重载，即同一个类中可以有多个同名但参数不同的方法；而运行时多态是指方法的重写，即子类可以重写父类的方法，从而实现不同的行为。
通过多态，可以实现面向对象编程中的“开闭原则”，即对扩展开放，对修改关闭。
C语言设计模式
C++有三个最重要的特点，即继承、封装、多态。
我发现其实C语言也是可以面向对象的，也是可以应用设计模式的，关键就在于如何实现面向对象语言的三个重要属性。
（1）继承性[cpp]view plaincopy1.typedef struct _parent2.{3.int data_parent;4.5.}Parent;6.7.typedef struct _Child8.{9.struct _parent parent;10.int data_child;11.12.}Child;在设计C语言继承性的时候，我们需要做的就是把基础数据放在继承的结构的首位置即可。
这样，不管是数据的访问、数据的强转、数据的访问都不会有什么问题。
（2）封装性[cpp]view plaincopy1.struct _Data;2.3.typedef void (*process)(struct _Data* pData);4.5.typedef struct _Data6.{7.int value;8. process pProcess;9.10.}Data;封装性的意义在于，函数和数据是绑在一起的，数据和数据是绑在一起的。
这样，我们就可以通过简单的一个结构指针访问到所有的数据，遍历所有的函数。
封装性，这是类拥有的属性，当然也是数据结构体拥有的属性。
（3）多态[cpp]view plaincopy1.typedef struct _Play2.{3.void* pData;4.void (*start_play)(struct _Play* pPlay);5.}Play;多态，就是说用同一的接口代码处理不同的数据。
比如说，这里的Play结构就是一个通用的数据结构，我们也不清楚pData是什么数据，start_play是什么处理函数？但是，我们处理的时候只要调用pPlay->start_play(pPlay)就可以了。
剩下来的事情我们不需要管，因为不同的接口会有不同的函数去处理，我们只要学会调用就可以了。
C语言中的多态实现方式
C语言中的多态实现方式
多态是面向对象编程中一个重要的概念，它允许不同的对象对同一个消息做出不同的响应。
在C语言中，虽然没有内置的多态特性，但我们可以通过一些技巧来实现多态效果。
一种常见的实现多态的方式是使用函数指针。
函数指针可以指向不同的函数，我们可以将函数指针作为参数传递给一个函数，然后根据不同的函数指针调用不同的函数。
这样就可以实现在运行时根据对象类型来选择不同的函数处理。
另一种实现多态的方式是使用结构体和函数指针的组合。
我们可以定义一个结构体，其中包含一个函数指针指向操作函数，然后针对不同类型的对象定义不同的操作函数。
通过这种方式，我们可以在运行时根据对象的类型来调用相应的操作函数，实现多态效果。
除此之外，我们还可以使用函数表来实现多态。
函数表是一个包含函数指针的数组，每个函数指针指向一个操作函数。
我们可以将函数表作为对象的一个成员变量，在运行时根据对象类型选择相应的函数表，然后调用相应的操作函数。
总结来说，虽然C语言本身并不支持多态特性，但通过使用函数指针、结构体和函数表等技巧，我们仍然可以在C语言中实现多态效果。
这些方法需要我们在设计程序结构时仔细思考，合理利用指针和结构体的特性，才能实现灵活而高效的多态效果。
希望以上内容能够帮助您了解C语言中的多态实现方式。
C语言中的多态与继承
C语言中的多态与继承多态和继承是面向对象编程中两个重要的概念。
它们不仅在C++等高级语言中有着广泛的应用，而且在C语言中也具备一定的实现方式。
本文将讨论C语言中的多态与继承，探讨它们的概念、特点以及在实际编程中的应用。
一、多态的概念与特点多态是指同一操作作用于不同的对象，可以有不同的解释和实现方式。
在C语言中，要实现多态性通常使用函数指针和结构体来模拟。
通过函数指针，可以实现对不同结构体中相同类型的成员进行访问，进而实现多态。
多态的特点有以下几个方面：1. 同一操作作用于不同对象，可以有不同的表现形式。
2. 多态性可以增加代码的灵活性和可扩展性。
3. 多态性可以提高代码的复用性和可读性。
二、继承的概念与特点继承是面向对象编程中的基本概念之一，它允许一个类（称为子类或派生类）继承另一个类（称为父类或基类）的属性和方法。
在C语言中，要实现继承通常使用结构体嵌套的方式来模拟。
继承的特点有以下几个方面：1. 子类可以拥有父类的属性和方法。
2. 子类可以覆盖父类的方法，实现自己的特定功能。
3. 继承可以实现代码的重用和扩展，提高代码的效率和可维护性。
三、C语言中多态与继承的应用在C语言中，多态和继承可以通过结构体、函数指针以及函数调用的方式来实现。
首先，我们需要定义一个基类结构体，包含一些通用的属性和方法。
然后，针对不同的具体情况，可以定义多个不同的派生类结构体，继承基类的属性和方法，并在派生类中实现自己特定的操作。
接下来，我们需要定义一个函数指针成员，用于指向不同派生类中的方法。
通过函数指针的动态绑定，可以在运行时确定调用哪一个具体的方法，实现多态的效果。
最后，在调用函数的时候，可以使用基类的指针指向不同的派生类对象，通过函数指针调用对应的方法。
由于函数指针的动态绑定，程序会根据对象的实际类型来决定调用哪个方法，实现多态的效果。
通过上述方式，我们可以在C语言中模拟出多态和继承的特性，实现代码的复用、扩展和灵活调用。
- 1、下载文档前请自行甄别文档内容的完整性，平台不提供额外的编辑、内容补充、找答案等附加服务。
- 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
- 3、如文档侵犯您的权益，请联系客服反馈,我们会尽快为您处理(人工客服工作时间：9:00-18:30)。
C语言下的封装、继承与多态上次课，钱SIR提到，Liux下面也有很多用C实现的面向对象的结构。
比较感觉兴趣，就在网上查了一些资料，原来C语言模拟实现面向对象语言所具有的特性：多态，继承，封装，也是一件很简单的事儿。
并且现在很多开源软件都了用C语言实现了这几个特性，包括大型开源数据库系统postgreSQL，可移植的C语言面向对象框架GObject。
在自己机器上实践了下，感叹C语言的灵活与强大！总结一下，以便交流：一、基础知识（1）结构体结构体可以嵌套,因而可以把一个结构体当成另一个结构体的成员，如：[cpp]view plaincopyprint?1.struct Point{2.int x;3.int y;4.};1.struct Circle {2.struct Point point_;3.int radius;4.};该结构体与以下定义完全一样（包括内存布置都一样[cpp]view plaincopyprint?1.struct Circle {2.int x;3.int y;4.int radius;5.};1.type VAFunction(type arg1, type arg2, … );标准C/C++包含头文件stdarg.h，该头文件中定义了操作不定变量的相关宏：[cpp]view plaincopyprint?1.void va_start ( va_list arg_ptr, prev_param ); /* ANSI version */2.type va_arg ( va_list arg_ptr, type );3.void va_end ( va_list arg_ptr );1.//========头文件：Point.h文件========2.#ifndef POINT_H3.#define POINT_H4.typedef struct Point point;5.typedef struct pointPrivate pointPrivate;6.<pre class="cpp" name="code">struct Point7.8.{9.struct pointPrivate *pp;};10.int get_x(point *point_);11.int get_y(point *point_);12.point * new_point(int x,int y);13.}14.#endif1.//=======C文件:Point.c文件========2.#include "Point.h"3.#include<stdlib.h>4.struct pointPrivate;5.int x;6.int y;7.};8.9.int get_x(point *point_){10.return point_->pp->x;11.}12.13.int get_y(point *point_){14.return point_->pp->y;15.}16.17.point* new_point(int x,int y){18.point* p=(point*)malloc(sizeof(point));19.p->pp=(pointPrivate*)malloc(sizeof(pointPrivate));20.p->pp->x=x;21.p->pp->y=y;22.return p;23.}1.int main()2.{3.point* p = new_point(1,2);4.//printf("x:%d,y:%d\n",p->pp->x,p->pp->y);5.printf("x:%d,y:%d\n",get_x(p),get_y(p));6.}1.//基类Base的内部头文件Base.r，对外隐藏2.#ifndef BASE_R3.#define BASE_R4.#include <stdarg h="">5.struct Base {6.size_t size;7.void * (* ctor) (void * self, va_list * app);//构造函数8.void * (* dtor) (void * self); //析构函数9.void (* draw) (const void * self);//作图函数10.};11.#endif12.13.//Point的内部头文件Point.r，对外隐藏14.#ifndef POINT_R15.#define POINT_R16.struct Point {17.const void * base; //继承Base类，基类指针，放在第一个位置，const是防止修改18.int x, y; //坐标19.};20.#define x(p) (((const struct Point *)(p)) -> x)21.#define y(p) (((const struct Point *)(p)) -> y)22.#endif23.24.//Point的头文件Point.h（对外提供接口）25.#ifndef POINT_H26.#define POINT_H27.extern const void * Point; /* new(Point, x, y); */28.void move (void * point, int dx, int dy);29.#endif30.31.//Point的源文件Point.c32.#include <stdio h="">33.#include "Point.h"34.#include "Point.r"35.#include "new.h"36.#include "Base.r"37./**********Point类自己的构造函数***********/38.static void * Point_ctor (void * _self, va_list * app){39.struct Point * self = _self;40.self -> x = va_arg(* app, int);41.self -> y = va_arg(* app, int);42.return self;43.}44./**********Point类自己的绘图函数***********/45.static void Point_draw (const void * _self){46.const struct Point * self = _self;47.printf("Point at %d,%d\n", self -> x, self -> y);48.}49.static const struct Base _Point = {50.sizeof(struct Point), Point_ctor, 0, Point_draw51.};52.const void * Point = & _Point;53.void move (void * _self, int dx, int dy){54.struct Point * self = _self;55.self -> x += dx, self -> y += dy;56.}57.58.//Circle内部头文件Circle.r，对外隐藏59.#ifndef CIRCLE_R60.#define CIRCLE_R61.#include "Point.r"62.struct Circle {63.const struct Point _; //继承Point类，需放在第一位64.int rad;65.};66.#endif67.68.//Circle的头文件Circle.h（对外提供接口）69.#ifndef CIRCLE_H70.#define CIRCLE_H71.#include "Point.h"72.extern const void * Circle; /* new(Circle, x, y, rad) */73.#endif74.75.//Circle的源文件Circle.c76.#include <stdio h="">77.#include "Circle.h"78.#include "Circle.r"79.#include "new.h"80.#include "Base.r"81./**********Circle类自己的构造函数***********/82.static void * Circle_ctor (void * _self, va_list * app){83.struct Circle * self = ((const struct Base *) Point) -> ctor(_self, app);84.self -> rad = va_arg(* app, int);85.return self;86.}87./**********Circle类自己的绘图函数***********/88.static void Circle_draw (const void * _self){89.const struct Circle * self = _self;90.printf("circle at %d,%d rad %d\n",x(self), y(self), self -> rad);91.}92.static const struct Base _Circle = {93.sizeof(struct Circle), Circle_ctor, 0, Circle_draw94.};95.const void * Circle = & _Circle;96.97.//内存管理类头文件new.h（对外提供接口）98.#ifndef NEW_H99.#define NEW_H100.void * new (const void * base, ...);101.void delete (void * item);102.void draw (const void * self);103.#endif104.105.//内存管理类的源文件：new.c106.#include <assert h="">107.#include <stdlib h="">108.#include <stdarg h="">109.#include "Base.r"110.void * new (const void * _class, ...){111.const struct Base * base = _class;112.void * p = calloc(1, base -> size);113.assert(p);114.* (const struct Base **) p = base;115.if (base -> ctor){116.va_list ap;117.va_start(ap, _class);118.p = base -> ctor(p, & ap);119.va_end(ap);120.}121.return p;122.}123.void delete (void * self){124.const struct Base ** cp = self;125.if (self && * cp && (* cp) -> dtor)126.self = (* cp) -> dtor(self);127.free(self);128.}129.void draw (const void * self){130.const struct Base * const * cp = self;131.assert(self && * cp && (* cp) -> draw);132.(* cp) -> draw(self);133.}</stdarg></stdlib></assert></stdio></stdio></stdarg>1.#include "Circle.h"2.#include "new.h"3.int main (int argc, char ** argv)4.{5.void * p;6.int i;7.for(i=0; i<2; i++)8.{9.if(i==0)10.p = new(Circle, 1, 2, 3);11.else12.p = new(Point, 1, 2);13.draw(p);14.move(p, 10, 20);15.draw(p);16.delete(p);17.}18.return 0;19.}。