专栏推荐Easyx学习实践
专栏里的知识都是通过林耿亮老师的课程中总结出来的，简洁明了，本节中也会用到一点Easyx中的小小的知识点，图形化编程还是很好玩的，欢迎大家去看一看喔。
在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，执行的是第三部中设置的方法。