C语言：使用结构体和指针函数实现面向对象思想（OO编程）

观察如下两个程序 a.c 和 b.c：
a.c

#define screen ((char *)0xb8000000)
typedef struct c
{
    char chr;
    char color;
    void (*put)(struct c*, int,int );
}ch;
void f(ch*, int, int);
int main(void)
{
    int n;
    ch a;
    a.chr = 'c';
    a.color = 2;
    a.put =f;
    a.put(&a,10,40);
    return;
}
void f(ch* p, int row, int col)
{
    screen[(row-1)*160+(col-1)*2] = p->chr;
    screen[(row-1)*160+(col-1)*2+1] = p->color;
    return;
}

b.c

#define screen ((char *)0xb8000000)
typedef struct c
{
    char chr;
    char color;
    void(*setch)(struct c*, char);
    void(*setcolor)(struct c*, char);
    void (*put)(struct c*, int,int );
}ch;
void f(ch*, int, int);
void f1(ch*, int, int);
void f2(ch*, int, int);
int main(void)
{
    int n;
    ch a;
    a.put =f;
    a.setch =f1;
    a.setcolor =f2;
    a.setch(&a,'c');
    a.setcolor(&a,2);
    a.put(&a,10,40);
    return;
}
void f(ch* p, int row, int col)
{
    screen[(row-1)*160+(col-1)*2] = p->chr;
    screen[(row-1)*160+(col-1)*2+1] = p->color;
    return;
}
void f1(ch* p, char)
{
    p->chr = a;
    return;
}

这两个程序都是要实现在屏幕上第 10 行 40 列打印一个绿色的字符 c：

这两个程序的数据组织方式是一样的，都是使用结构体，而且对共性和个性的分离的思路也是一样的，都是将共性封装在 main 函数里，将个性实现在子函数里。

但是 a.c 和 b.c 封装和分离的角度是不一样的：

a.c 没有将字符和颜色的属性赋值分离出来，而只是将显示功能分离出来，

b.c 将字符、颜色的赋值和显示功能都分离了出来，用三个子函数实现，并将相对应的函数指针封装到结构体里去。

面向对象程序设计的一条基本原则是计算机程序是由单个能够起到子程序作用的单元或对象组合而成，也就是说我们要尽量把功能以子函数的形式实现。

所以在这里虽然 a 和 b 的设计思想是相同的，但是 b.c 的封装性要比 a.c 的封装性更好。

再来看下一个程序：

现在要在？处添加语句，使程序能够实现功能。

这里 ch a=new （ch）；的功能应该与 ch a；相同，即定义一个 struct c 型的结构体变量 a。但是我们用 ch a；是开辟了一个 ch 大小的空间并把它命名为 a，而这里 ch a=？只是对一个指针进行了赋值，我们一般对指针赋值只是把一个地址给它，并没有开辟空间，但是我们要实现 ch a；的功能，必须要在这一句里对该地址开辟空间。现在的问题就是：怎么在给指针赋值时开辟内存空间？

我们知道数组在定义时可以开辟空间，但是数组定义需要单独的一句，而这里需要直接作为右值使用，所以这里需要动态地开辟空间。我们最常用的动态内存分配方法就是使用 malloc 函数，这个函数有一个参数，是要开辟的空间字节数，在这里我们要开辟的空间大小是结构体 a 的大小，但是我们不知道结构体 a 的大小，所以我们要用 sizeof 得出它的大小。用 malloc 开辟空间后再将其转换成结构体指针赋给 a，程序如下：

我们之前使用过宏定义，但是在程序中是宏名直接替换掉后面的东西的，而这里宏有参数 x，所以它是带参宏定义，它的格式为：#define 宏名 (形参表) 字符串。这里的 x 就是一个形参。所以我们要在使用时在宏名后面传入实参。

这里的宏名是 new，学过 java 我们会发现 java 里初始化对象也是使用 new，这里的 new 其实也是实现一个相似的功能。我们可以把结构体 ch 理解成一个类，用 new 对它进行实例化，这样就可以实现面向对象的程序设计思想。其实 java 里实例化对象也是开辟一个内存空间并给这个空间取一个名字即对象名。结构体为什么可以实现类的功能呢？我们知道，类里面可以定义变量、数组、函数，并进行一些操作如赋值、调用函数之类的，只是在 java 中类里面程序员不能定义和使用指针进行操作。而结构体里面也可以进行定义变量、数组、函数指针等的操作，所以如果我们要用 c 语言编写具有面向对象思想的程序，我们可以用结构体来实现类似 “类” 的功能，并用带参宏定义来实现实例化的功能，或者可以直接用 malloc 函数来实现实例化，只不过这样语句比较重复。

虽然我们可以在 c 语言里面用这种方法实现面向对象的程序设计，但是这样毕竟不如用 java 之类的比较适合面向对象的语言来写有面向对象思想的程序。因为 java 的类里可以进行赋值、调用函数等功能而 c 里的结构体不能。java 取消了程序员使用指针的权限，因为如果在这种高度封装的语言里使用指针很可能造成很多错误。

从这里看，面向对象和面向过程程序设计思想的区别在哪里呢？面向对象的程序可能需要更多的封装，它的每一个对象都是为执行特定的功能而封装的，对象与对象之间相对比较独立，关系清晰，便于程序的功能细化、管理维护，但是也会造成程序的代码量增大。面向过程的程序封装的主要是一些数据结构，一个函数、变量可以被以多种角度来使用，这样使程序变得十分精简短小，但是不容易修改和补充。

我们写程序是用来解决问题的，而且要解决的是现实中的问题，所以我们需要将现实问题转化为符号化的问题，而现实中的问题是由个体所组成的，所以我们将数据和处理数据的方法封装起来形成一个个体，这个个体在问题里面有专门的功能，比如一张纸可以折叠，一支笔可以写，这样有助于我们以自身的角度进行思考分析，这就是面向对象。如果用面向过程的思路，会导致问题与程序之间的转化不好处理，可能使解决问题出现偏差。

二、扩展研究

1、动态开辟内存空间的函数有哪些？

答：c 语言有三个函数可以动态开辟数组：malloc 函数、calloc 函数、realloc 函数。

c 语言提供了 malloc 函数和 free 函数用来执行动态内存分配和释放，这些函数维护一个可用内存池，malloc 函数可以从内存池中提取一块合适的内存，free 函数用来释放这块内存以供别的程序使用。Malloc 函数分配的是一块连续的内存，返回值是一个指向被分配的内存块起始位置的指针。Malloc 实际分配的内存可能比你请求的的多一点，也可能不会，这是由编译器决定的。但是 malloc 也可能分配失败，如果操作系统无法向 malloc 函数提供足够的可用内存，那么它会返回一个 NULL 指针。Malloc 返回的指针类型为 void *型。Free 的参数必须要么是 NULL，要么是 malloc 函数、calloc 函数、realloc 函数返回的值。

Calloc 函数的参数是所需元素的数量和每个元素的字节数，而不是总的字节数。Calloc 会把分配的内存都初始化为 0，而 malloc 不会初始化。

Realloc 函数用于修改一个原先已分配的内存块的大小，如果原先的内存块大小无法改变，那么 realloc 会分配另一块正确大小的内存，并把原先那块内存的内容复制到新的块上。如果 realloc 的第一个参数为 NULL，那么它的作用和 malloc 一样。

三、研究总结

这一章里我们学习了动态分配内存的方法，以及怎么使用宏定义，其实它们都是为了更好地进行封装。为了对程序进行更好地封装，人们使用了各种方式，甚至开发了封装性更强的高级语言，这使我们解决专门问题的能力更强了。这样我们编程只是将共性实现为个性。因为语言只是工具，程序员应该更专注地研究算法而不是把时间花在语言上，所以现在的语言都是为了简化程序员的工作所造成的。

我们封装的过程，是对事物进行抽象的过程，也是对事物进行认识的过程，我们从开始到现在，封装的层次越来越深，处理的问题也越来越复杂。因为我们需要理清复杂问题的内部规律，从而找出解决问题的办法，而深层次的封装使问题恢复成本来的样子就是一种解决办法，当封装的程度达到了一定的水平，就是面向对象的程序设计思想。

如果说我的文章对你有用，只不过是我站在巨人的肩膀上再继续努力罢了。
若在页首无特别声明，本篇文章由 Schips 经过整理后发布。

博客地址：https://www.cnblogs.com/schips/
https://www.cnblogs.com/schips/p/10674696.html