在C语言中，我们解决一个问题通常是采用在了解了问题如何解决后，设置一个一个的函数，依次调用实现不同的功能的函数从而解决问题，这种编程风格就叫做面向过程。
除此之外，还有一种叫做面向对象的编程风格被广泛的使用，面向对象采用基于对象的概念建立模型，对现实世界进行模拟，不仅能使我们的代码结构更加紧凑，精简且富有逻辑，很多耳熟能详的高级语言都采用的是面向对象的编程风格，例如C++，Java,python等。
以学校为场景，首先来介绍封装。
封装
学校里必定有很多学生，每个学生都有自己的属性，例如姓名，学号，性别，分数等。
我们自然会设置一个结构体用来表示学生
typedef struct student { int id; char name[20]; int gender; int mark; }Stu;
为了给每个学生设置学号，我们自然要写一个函数，用来给每一位学生添加自己的学号。
通过一个学生的入学年份，班级，序号生成该学生的id。函数如下
int makeStudentId(int year, int classNum, int serialNum) { char buffer[20]; sprintf(buffer, "%d%d%d", year, classNum, serialNum); int id = atoi(buffer);//将字符串化作一个完整的数组。 return id; }
atoi函数将一串数字字符转移为一个整形，使用该函数需要包含头文件stdlib.h。
sprint函数将后置内容放在字符串而不是直接打印到输出台，详见C语言文件操作。
学生的性别用整形来表示，如果0就是男，1就是女。
两个函数进行整形和字符男女间的转化,在存储时存储整形，在取出时转化为汉字男女。
const char* numGenderToStrGender(int numGerder) { if (numGerder == 0) { return "男"; } else if (numGerder == 1) { return "女"; } return "未知"; } int strGenderToNumGender(const char* strGender) { int numGender; if (strcmp("男", strGender) == 0)//比较 { numGender = 0;//0代表男 } else if (strcmp("女", strGender) == 0) { numGender = 1;//1代表女 } else { numGender = -1;//未知类型 } return numGender; }
正如其名，第一个函数是将整形数据转化为字符男，女。第二个函数是将字符男女转化为整形。
将结构体和函数声明放在另一个文件，school.h，函数放在school.cpp中，就可以在test.c文件中使用为学生设置其独有属性。
这里设置小明的学号生成函数，性别转化函数从而实现需求。
我么看头文件中的代码
typedef struct student { int id; char name[20]; int gender; int mark; }Stu; int makeStudentId(int year, int classNum, int serialNum); const char* numGenderToStrGender(int numGerder); int strGenderToNumGender(const char* strGender);
结构体被称作数据，而函数被称为方法，在面向过程的编程风格中，方法和数据是分离的，函数不能直接操作数据，我们需要拿到函数的返回值再给数据赋值。
面向对象编程风格的第一大特性就是封装，他希望方法能够直接操作数据，而不是通过借助返回值的方法操作数据，将方法和数据结合起来构成一个整体，而这个整体就叫做对象。即对象包含数据和方法。
命名·规则：
一般来说获取数据的方法称作getXXX。设置数据的方法称作setXXX。
现在我们来修改上边的函数
将函数的第一个参数设置为结构体指针，修改函数名如上边的规则。
void setStudentId(Stu * stu,int year, int classNum, int serialNum); const char* getStrGender(Stu* stu); void setGender(Stu* stu,const char* strGender);
函数体内同样要发生变化
void setStudentId(Stu* stu, int year, int classNum, int serialNum)//无需返回值，返回值类型改为void { char buffer[20]; sprintf(buffer, "%d%d%d", year, classNum, serialNum); int id = atoi(buffer);//将字符串化作一个完整的数组。 //return id;不需要返回Id的值了。 stu->id = id;//直接操作数据 } const char* getStrGender(Stu* stu) { if (stu->gender == 0) { return "男"; } else if (stu->gender == 1)//直接使用结构体中的gender进行判断 { return "女"; } return "未知"; } void setGender(Stu* stu, const char* strGender) { int numGender; if (strcmp("男", strGender) == 0)//比较 { numGender = 0;//0代表男 } else if (strcmp("女", strGender) == 0) { numGender = 1;//1代表女 } else { numGender = -1;//未知类型 } stu->gender = numGender; }
使用如下：
现在函数已经可以直接操作数据了，但是函数和数据仍然是两个独立的部分。
我们要将函数和数据结合在一起，这样整个整体就叫做对象，函数称为属于这个对象的方法。
大多数面向对象的语言，都提供了这样的格式调用一个对象的方法。**C++会自动将一个对象指针this作为方法的参数，而C语言不支持，所以我们要手动传对象指针。**
例如
这样就可以调用setGender函数，在参数里传入男，方法就可以将男转化为整型，并设置到对象stu中，通过这种方法就可以将数据和方法结合。
通过对象点加方法的形式，就可以在对象数据中获取整形表示的性别，并返回性别对应的字符串。
typedef struct student { //声明函数指针 void (*setStudentId)(Stu* stu, int year, int classNum, int serialNum); const char* (*getStrGender)(Stu* stu); void (*setGender)(Stu* stu, const char* strGender); int id; char name[20]; int gender; int mark; }Stu;
函数指针都是函数名前加上*号这种格式来编写的，为了让函数指针有正确的指向，我们许哟一个初始化函数，将函数指针初始化。
void initStudent(struct student* s)//初始化结构体 { s->setGender = setGender;//用之前定义好的三个函数将三个函数指针初始化。 s->getStrGender = getStrGender; s->setStudentId = setStudentId; }
现在我们就可以使用对象.方法的形式调用该方法的对象了。
如图
继承
学校里不仅有学生，当然还有老师等等，老师也有自己的性质，但是和学生具有某些相同的属性，例如性别，年龄，名字。
学生具有考试分数，老师有任课科目，我们可以将两个结构体的共同之处抽象出来，因为他们都是人，所以构造一个person结构体（类）。
typedef struct person { int id; char name[20]; int gender; }Per;
这个结构体具有老师和学生的共性，可以让老师和学生包含person对象。
与上边图片两种结构体相比，现在构造的结构体如下。
typedef struct person { int id; char name[20]; int gender; }Per; typedef struct student { Per person; int mark; }Stu; typedef struct tescher { Per person; char subject[20]; }Tes;
将他们的共性抽象出来person结构体，不仅可以减少重复代码，还可以使代码层次更加清晰。从这个小例子来看，代码量明显增加了，然而需要再多定义更过的职业属性，就会发现节省很多代码量。
因为student和teacher具有person的一切，所以可以说
Student与teacher均继承于person。 person是teacher和student的父对象
student和teacher是person的子对象。
刚刚我们给学生类创建了很多方法，其中设置id的和性别的方法当然也可以用在teacher类中。将这两个方法抽象出来，移动到person结构体中，且将方法改为Per的方法。
三种结构体声明如下
typedef struct person { int id; char name[20]; int gender; const char* (*getStrGender)(struct person* stu);//将参数名改为person void (*setGender)(struct person* stu, const char* strGender);//将参数名改为person }Per; typedef struct teacher { Per person; char subject[20]; }Tea; typedef struct student { //声明函数指针 void (*setStudentId)(struct student* stu, int year, int classNum, int serialNum);//设置学好的方法为学生独有的方法 Per person; int mark; }Stu; void setGender(Per*p, const char* strGender); const char* getGender(Per*p); void setStudentId(Stu*stu, int year, int classNum, int serialNum); void initPerson(Per* p); void initStudent(Stu* stu); void initTeacher(Tea* t);
初始化函数对比如下
//void initStudent(struct student* s)//初始化结构体 //{ // s->setGender = setGender;//用之前定义好的三个函数将三个函数指针初始化。 // s->getStrGender = getStrGender; // s->setStudentId = setStudentId; //} //初始化函数 void initPerson(Per* p) { p->gender = getGender; p->setGender = setGender; } void initStudent(Stu* stu) { initPerson(&(stu->person)); stu->setStudentId = setStudentId; } void initTeacher(Tea* t) { initPerson(&(t->person)); }
由于控制性别的方法现在在person类中，故函数的传参也要变化，对比如下（当然setGender也要变化）
//const char* getStrGender(Stu* stu) //{ // if (stu->gender == 0) // { // return "男"; // } // else if (stu->gender == 1)//直接使用结构体中的gender进行判断 // { // return "女"; // } // return "未知"; //} const char* getStrGender(Per* p) { if (p->gender == 0) { return "男"; } else if (p->gender == 1)//直接使用结构体中的gender进行判断 { return "女"; } return "未知"; }
这样就可以使用teacher和student结构体定义新的类变量。至于学生设置id的函数不用变化即可。
我们可以测试一下
没一点问题！
多态
现在有三种形状分别是圆形，方形和三角形。我们用三种结构来表示他们，他们都要有绘制的方法，代码如下。
#include <easyx.h> #include <stdio.h> #include <stdlib.h> struct Rect { int left; int top; int right; int bottom; void (*draw)(struct Rect*);//封装 }; struct Circle { int x; int y; int r; void (*draw)(struct Circle*);//封装 }; struct Triangle { POINT p1; POINT p2; POINT p3; void (*draw)(struct Triangle*);//封装 }; void drawRect(struct Rect* r) { rectangle(r->left, r->top, r->right, r->bottom); } void drawCircle(struct Circle* c) { circle(c->x, c->y, c->r); } void drawTriangle(struct Triangle* t) { line(t->p1.x, t->p1.y, t->p2.x, t->p2.y); line(t->p2.x, t->p2.y, t->p3.x, t->p3.y); line(t->p3.x, t->p3.y, t->p1.x, t->p1.y); } void initRect(struct Rect* r) { r->draw = drawRect; } void initCircle(struct Circle* c) { c->draw = drawCircle; } void initTriangle(struct Triangle* t) { t->draw = drawTriangle; } int main() { initgraph(800, 600); setaspectratio(1, -1); setorigin(400, 300); setbkcolor(WHITE); setlinecolor(BLACK); cleardevice(); struct Rect r = { -200,200,200,0 }; struct Circle c = { 0,0,100 }; struct Triangle t = { {0,200},{-200,0},{200,0} }; initRect(&r); initCircle(&c); initTriangle(&t); r.draw(&r); c.draw(&c); t.draw(&t); getchar(); return 0; }
多态
可以发现上边圆方三角三个结构体都有draw方法，我们可以将draw这个方法抽象出来，单独放在一个结构体中，由于这三个对象都是图形，我们将新的结构体命名为shape。
将三个对象包含shape这个结构体，这里要注意以下父对象与子对象的内存排布必须重合。
上边是可行的
修改各对象的初始化函数，由于左侧参数和右边参数类型不一致，所以初始化时要进行强转。
void initRect(struct Rect* r) { r->super.draw = (void (*)(struct Shape*))drawRect;//左侧参数为void (*)(struct Shape*),而右边类型分别为void (*)(struct Rect*) } void initCircle(struct Circle* c)//函数内部类型不一致，无法进行复制，可以强制进行转换 { c->super.draw = (void (*)(struct Shape*))drawCircle; } void initTriangle(struct Triangle* t) { t->super.draw = (void (*)(struct Shape*))drawTriangle; }
使用初始化列表将声明的对象初始化。
struct Rect r = { {}, - 200,200,200,0 }; struct Circle c = { {},0,0,100 }; struct Triangle t = { {}, {0,200},{-200,0},{200,0} };
第一个成员为super，所以要留出他的位置。
如何使用呢？
还是要先初始化。代码如下
initRect(&r); initCircle(&c); initTriangle(&t); struct Shape* arrShape[3] = { (struct Shape*)&r,(struct Shape*)&c,(struct Shape*)&t };//结构体数组 for (int i = 0; i < 3; i++) { arrShape[i]->draw(arrShape[i]);//强制转换后，虽然调用的是shape里的draw函数，但是在数组里强制类型转换，所以可以实现同样效果 }
两种对比一下会更加清晰（不知道清晰不清晰，希望对大家有所帮助）
运行后如下
多态总结
实现多态的步骤
- 抽离出各个对象中共有的方法draw，将其单独放置在一个对象Shape中。
- 各个对象军继承与Shape对象
- 将各个对象中的draw方法设置为各自的实现方法
- 声明一个shape对象的指针，并将其赋值为有一个子对象的指针
- 通过上述对象指针，调用方法共用方法draw，执行的是第三部中设置的方法。
