一、前言

在嵌入式开发中，C/C++语言是使用最普及的，在C++11版本之前，它们的语法是比较相似的，只不过C++提供了面向对象的编程方式。

虽然C++语言是从C语言发展而来的，但是今天的C++已经不是当年的C语言的扩展了，从2011版本开始，更像是一门全新的语言。

那么没有想过，当初为什么要扩展出C++？C语言有什么样的缺点导致C++的产生？

C++在这几个问题上的解决的确很好，但是随着语言标准的逐步扩充，C++语言的学习难度也逐渐加大。没有开发过几个项目，都不好意思说自己学会了C++，那些左值、右值、模板、模板参数、可变模板参数等等一堆的概念，真的不是使用2，3年就可以熟练掌握的。

但是，C语言也有很多的优点：

其实最后一个优点是最重要的：使用的人越多，生命力就越强。就像现在的社会一样，不是优者生存，而是适者生存。

这篇文章，我们就来聊聊如何在C语言中利用面向对象的思想来编程。也许你在项目中用不到，但是也强烈建议你看一下，因为我之前在跳槽的时候就两次被问到这个问题。

二、什么是面向对象编程

有这么一个公式：程序=数据结构+算法。

C语言中一般使用面向过程编程，就是分析出解决问题所需要的步骤，然后用函数把这些步骤一步一步调用，在函数中对数据结构进行处理(执行算法)，也就是说数据结构和算法是分开的。

C++语言把数据和算法封装在一起，形成一个整体，无论是对它的属性进行操作、还是对它的行为进行调用，都是通过一个对象来执行，这就是面向对象编程思想。

如果用C语言来模拟这样的编程方式，需要解决3个问题：

• 数据的封装
• 继承
• 多态
  

第一个问题：封装

封装描述的是数据的组织形式，就是把属于一个对象的所有属性(数据)组织在一起，C语言中的结构体类型天生就支持这一点。

第二个问题：继承

继承描述的是对象之间的关系，子类通过继承父类，自动拥有父类中的属性和行为(也就是方法)。这个问题只要理解了C语言的内存模型，也不是问题，只要在子类结构体中的第一个成员变量的位置放置一个父类结构体变量，那么子类对象就继承了父类中的属性。

另外补充一点：学习任何一种语言，一定要理解内存模型！

第三个问题：多态

按字面理解，多态就是“多种状态”，描述的是一种动态的行为。在C++中，只有通过基类引用或者指针，去调用虚函数的时候才发生多态，也就是说多态是发生在运行期间的，C++内部通过一个虚表来实现多态。那么在C语言中，我们也可以按照这个思路来实现。

如果一门语言只支持类，而不支持多态，只能说它是基于对象的，而不是面向对象的。

既然思路上没有问题，那么我们就来简单的实现一个。

三、先实现一个父类，解决封装的问题

Animal.h

1. 
   
2. #ifndef _ANIMAL_H_
   * k- B: U: Q$ e* Q+ u2 y7 J! G
3. #define _ANIMAL_H_
   2 `8 |& P- o! P3 b& o
4. 
   
5. // 定义父类结构
   0 D4 X: z. A# O- {3 n1 G1 d" E$ ~! ~
6. typedef struct {
   
7.     int age;
   1 N) X* m: {7 ]" O! R
8.     int weight;
   / E/ l, x# `: m4 v, n
9. } Animal;
   $ L; ]& x0 L7 k0 i  O  c0 r$ f
10. 
    
11. // 构造函数声明
    9 H, }' f& G, c; A, _7 v' b
12. void Animal_Ctor(Animal *this, int age, int weight);
    
13. 
    , p0 o, i7 X: E& A- p, R2 l
14. // 获取父类属性声明
    ) p( e% a, O  D) ]" |
15. int Animal_GetAge(Animal *this);
    
16. int Animal_GetWeight(Animal *this);
    % c0 A8 P1 f, J. b- g* F
17. 
    6 a! a4 |6 m/ g% E' _8 o& @3 ]+ R
18. #endif

复制代码

Animal.c

1. 
   " f. S" A$ a  p, V
2. #include "Animal.h"
   $ R$ _& X$ ]7 ^2 ^, X- x" |0 [, {. O
3. 
   # X3 {# }1 F( d3 M, `
4. // 父类构造函数实现
   9 B6 ?9 u2 w4 ]! C$ `5 t6 e" r) l
5. void Animal_Ctor(Animal *this, int age, int weight)
   - y* s3 k$ d  g5 }' ~& Z- Y
6. {
   
7.     this->age = age;
   , a1 \7 V. A( M4 o
8.     this->weight = weight;
   
9. }
   % A$ U5 \5 ~. m+ U1 j
10. 
    8 h4 S1 J+ S  \( f8 M& U' |
11. int Animal_GetAge(Animal *this)
    
12. {
    
13.     return this->age;
    
14. }
    % [( c0 P0 C6 X# _+ W9 d; N) e
15. 
    7 L' z" ?8 D0 V* v
16. int Animal_GetWeight(Animal *this)
    8 h) ?1 t9 _2 e
17. {
    * N# a; c% L7 u) {3 w) j8 d2 f4 v9 n
18.     return this->weight;
    6 F9 w# H' @! }; E; `
19. }

复制代码

' ~( w5 ?- n9 t! R

测试一下：

1. 
   / Z* ?6 M! W" K+ p  y# d
2. #include <stdio.h>
   
3. #include "Animal.h"
   8 L3 [0 w5 h4 Q5 d
4. #include "Dog.h"
   ; d0 ?4 l1 v3 @" g& Y4 \
5. 
   
6. int main()
   9 ?0 b/ Z5 V' j2 X  i
7. {
   
8.     // 在栈上创建一个对象
   7 {' b% a9 `7 M: Q, P2 o
9.     Animal a;  
   ' z" z/ }0 m, [( V) v- g) _
10.     // 构造对象
    
11.     Animal_Ctor(&a, 1, 3);
    
12.     printf("age = %d, weight = %d \n",
    
13.             Animal_GetAge(&a),
    7 c9 P6 B9 h9 |, i
14.             Animal_GetWeight(&a));
    . |9 i7 X7 w6 n
15.     return 0;
    * i3 O3 [% m0 Q5 [9 F3 I7 C
16. }

复制代码

可以简单的理解为：在代码段有一块空间，存储着可以处理Animal对象的函数；在栈中有一块空间，存储着a对象。

与C++对比：在C++的方法中，隐含着第一个参数this指针。当调用一个对象的方法时，编译器会自动把对象的地址传递给这个指针。

所以，在Animal.h中函数我们就模拟一下，显示的定义这个this指针，在调用时主动把对象的地址传递给它，这样的话，函数就可以对任意一个Animal对象进行处理了。

四、 实现一个子类，解决继承的问题

Dog.h

1. 
   4 r! r! P3 }# Z& ]
2. #ifndef _DOG_H_
   ; o* m, Q, e1 @% I
3. #define _DOG_H_
   0 s3 m! n- S/ ]3 [5 J2 R
4. 
   % z4 T$ j7 ~1 m- {
5. #include "Animal.h"
   ! u: O; Y* x0 R' m2 e$ L, o: p3 J
6. 
   
7. // 定义子类结构
   3 T/ Z9 i: p6 {' n' M5 M# {
8. typedef struct {
   
9.     Animal parent; // 第一个位置放置父类结构
   
10.     int legs;      // 添加子类自己的属性
    
11. }Dog;
    # f6 A$ A7 U% K9 [# {: l
12. 
    , I7 o! {7 Z' h+ A0 R0 u; @: C
13. // 子类构造函数声明
    6 I: N% E" m6 O; ^
14. void Dog_Ctor(Dog *this, int age, int weight, int legs);
    
15. 
    - E4 p- e. c# I/ z) D- F: V8 a$ X9 Q
16. // 子类属性声明
    
17. int Dog_GetAge(Dog *this);
    
18. int Dog_GetWeight(Dog *this);
    
19. int Dog_GetLegs(Dog *this);
    
20. 
    
21. #endif

复制代码

Dog.c

1. 
   8 n0 H* r- j; x
2. #include "Dog.h"
   ' ~6 E) e( E: {! F. P, ?9 L% T
3. 
   / \% u" E  U9 Q+ i1 Z' E4 k
4. // 子类构造函数实现
   ; u5 k) W  N0 F
5. void Dog_Ctor(Dog *this, int age, int weight, int legs)
   6 |- e5 M$ j5 F$ o
6. {
   7 s' {- [% d8 }/ b: J  r/ R- S, _, S
7.     // 首先调用父类构造函数，来初始化从父类继承的数据
   ; Q3 _5 W; [& K8 @! p3 C
8.     Animal_Ctor(&this->parent, age, weight);
   , {9 B7 a# J* n8 h
9.     // 然后初始化子类自己的数据
   * d7 _. |/ e2 P
10.     this->legs = legs;
    . y) b0 d) }# f1 I/ @+ H
11. }
    * H  ~0 O: b6 y$ L- i* h; z9 y
12. 
    
13. int Dog_GetAge(Dog *this)
    
14. {
    
15.     // age属性是继承而来，转发给父类中的获取属性函数
    
16.     return Animal_GetAge(&this->parent);
    
17. }
    
18. 
    & c2 l! j9 F, v! n8 E
19. int Dog_GetWeight(Dog *this)
    
20. {
    
21.     return Animal_GetWeight(&this->parent);
    
22. }
    # ^  w% L: n: `" V/ }
23. 
    # m" [0 ]% c2 R* |2 M, E
24. int Dog_GetLegs(Dog *this)
    , M9 }: Z% c, o) r, g9 `
25. {
    
26.     // 子类自己的属性，直接返回
      ^' I# J4 m& ?9 F
27.     return this->legs;
    
28. }

复制代码

测试一下：

1. 
   6 u& x6 ~6 A0 B! r+ U
2. int main()
   4 k0 B& K- Q- Y
3. {
   
4.     Dog d;
   8 f& V' m' g  R8 Y9 Y- J: E! h
5.     Dog_Ctor(&d, 1, 3, 4);
   ( M* r- q+ ?% I
6.     printf("age = %d, weight = %d, legs = %d \n",
   7 W8 j9 Z* W* R% c( B
7.             Dog_GetAge(&d),
   
8.             Dog_GetWeight(&d),
   7 C( R4 a1 i5 E0 {+ @' M
9.             Dog_GetLegs(&d));
   ! d) u5 O# Y; N
10.     return 0;
    * }  p7 \. I# p& X6 W: k0 ^0 X0 q
11. }

复制代码

在代码段有一块空间，存储着可以处理Dog对象的函数；在栈中有一块空间，存储着d对象。由于Dog结构体中的第一个参数是Animal对象，所以从内存模型上看，子类就包含了父类中定义的属性。

Dog的内存模型中开头部分就自动包括了Animal中的成员，也即是说Dog继承了Animal的属性。

五、利用虚函数，解决多态问题

在C++中，如果一个父类中定义了虚函数，那么编译器就会在这个内存中开辟一块空间放置虚表，这张表里的每一个item都是一个函数指针，然后在父类的内存模型中放一个虚表指针，指向上面这个虚表。

上面这段描述不是十分准确，主要看各家编译器的处理方式，不过大部分C++处理器都是这么干的，我们可以想这么理解。

子类在继承父类之后，在内存中又会开辟一块空间来放置子类自己的虚表，然后让继承而来的虚表指针指向子类自己的虚表。

既然C++是这么做的，那我们就用C来手动模拟这个行为：创建虚表和虚表指针。

1. Animal.h为父类Animal中，添加虚表和虚表指针
/ q( Y/ X( Z& ]/ |, @8 s2 @" l

1. 
   
2. #ifndef _ANIMAL_H_
   $ v6 C9 d) X! |- N
3. #define _ANIMAL_H_
   ( f) d  Q, z6 H+ N# h
4. 
   
5. struct AnimalVTable;  // 父类虚表的前置声明
   2 O- C! z  Z5 p( Q. U0 G* I1 W* s
6. 
   
7. // 父类结构
   
8. typedef struct {
   8 I* h& d: K8 l% D3 i( u
9.     struct AnimalVTable *vptr; // 虚表指针
   
10.     int age;
    
11.     int weight;
    
12. } Animal;
    2 }6 a/ p& C" g0 o
13. 
    & _) P) f' H- w, N3 _
14. // 父类中的虚表
    ( @% W$ G$ W+ M9 e' ~; q
15. struct AnimalVTable{
    
16.     void (*say)(Animal *this); // 虚函数指针
    
17. };
    " w( \: K( V: m5 C9 R/ T/ f: p
18. 
    4 Y! h; C- c' H4 x' Y# O
19. // 父类中实现的虚函数
    
20. void Animal_Say(Animal *this);
    ; T: B3 A3 \: P8 L, `% r. i
21. 
    , b8 e' |) m2 u% M9 U! _# [; Q3 f  C
22. #endif

复制代码

2. Animal.c

1. 
   2 N+ H, ~9 f3 C5 _" J0 J/ N$ X8 i
2. #include <assert.h>
   
3. #include "Animal.h"
   4 T" \8 r& m& c7 q6 |
4. 
   9 x' L  i9 c- V+ H# D* z# Q; M
5. // 父类中虚函数的具体实现
   
6. static void _Animal_Say(Animal *this)
   ' ]1 F4 ~3 r$ J+ t7 f
7. {
   + s! L# ~, n& _& H' G0 W* R! ~. Z) J
8.     // 因为父类Animal是一个抽象的东西，不应该被实例化。
   ( K! x% x. ~" ]1 v
9.     // 父类中的这个虚函数不应该被调用，也就是说子类必须实现这个虚函数。
   * V: F$ J1 K4 }1 k3 g
10.     // 类似于C++中的纯虚函数。
    
11.     assert(0);
    + C3 w- m0 s$ h3 ^- Q: O
12. }
    6 E7 \4 B4 v# Q) X8 ^2 {5 k6 x
13. 
    
14. // 父类构造函数
    0 N5 R8 `% i2 z$ `- T: l
15. void Animal_Ctor(Animal *this, int age, int weight)
    
16. {
    
17.     // 首先定义一个虚表
    5 [' U1 u) a& b2 N/ k
18.     static struct AnimalVTable animal_vtbl = {_Animal_Say};
    # Q5 M/ G6 j7 j0 m. j1 c$ \$ o
19.     // 让虚表指针指向上面这个虚表
    
20.     this->vptr = &animal_vtbl;
    , J" U# ]) p# a7 P7 N" r/ Y" Z8 W. J
21.     this->age = age;
    ) _: [$ A+ B( g
22.     this->weight = weight;
    ; b! a) ?2 U4 I; V3 L+ M. P( \
23. }
    
24. 
    
25. // 测试多态：传入的参数类型是父类指针
    , P# d5 |2 N& M- I% i/ c, U( W
26. void Animal_Say(Animal *this)
    ' M& \7 c/ D" a& c+ y) ^6 d. \
27. {
    
28.     // 如果this实际指向一个子类Dog对象，那么this->vptr这个虚表指针指向子类自己的虚表，
    
29.     // 因此，this->vptr->say将会调用子类虚表中的函数。
    
30.     this->vptr->say(this);
    
31. }

复制代码

' t2 |2 O" [0 l

在栈空间定义了一个虚函数表animal_vtbl，这个表中的每一项都是一个函数指针，例如：函数指针say就指向了代码段中的函数_Animal_Say()。  > 对象a的第一个成员vptr是一个指针，指向了这个虚函数表animal_vtbl。

3.  Dog.h不变
# y/ u0 A7 ~! _' k4. Dog.c中定义子类自己的虚表
: n) ~9 x! y3 g" ~0 m, E

1. 
   
2. #include "Dog.h"
   
3. 
   - `! A' j- z' |- j0 W, v' l9 Q; o
4. // 子类中虚函数的具体实现
   ; e9 x3 e2 c0 x( K$ l
5. static void _Dog_Say(Dog *this)
   , o# N( v# ?8 m. N
6. {
   
7.     printf("dag say \n");
   
8. }
   1 g+ q  v8 I6 u- t- x
9. 
     ~  q: _7 p2 O; X
10. // 子类构造函数
    
11. void Dog_Ctor(Dog *this, int age, int weight, int legs)
    ' B0 Q3 D; I$ K, y1 H% `& w
12. {
    % `; |; V0 i; S  m/ o: O0 C
13.     // 首先调用父类构造函数。
    , A6 }: V6 q( V1 U: b3 }- C
14.     Animal_Ctor(&this->parent, age, weight);
    ( A8 i% Y5 t. J
15.     // 定义子类自己的虚函数表
    9 u% k1 M4 K& `, G. Y9 q5 G$ [
16.     static struct AnimalVTable dog_vtbl = {_Dog_Say};
    
17.     // 把从父类中继承得到的虚表指针指向子类自己的虚表
    6 V3 [# S! B. J; ^
18.     this->parent.vptr = &dog_vtbl;
    
19.     // 初始化子类自己的属性
    
20.     this->legs = legs;
    4 f" b4 W& a4 b
21. }

复制代码

# N8 T. K& n, h/ ^5. 测试一下

1. 
   ; ]0 N2 S1 }3 t+ z" U8 R
2. int main()
   
3. {
   
4.     // 在栈中创建一个子类Dog对象
   
5.     Dog d;  
   / Q: {5 i: Q! ?. R5 t
6.     Dog_Ctor(&d, 1, 3, 4);
   # `1 y1 a- F2 t
7. 
   
8.     // 把子类对象赋值给父类指针
   1 |/ W4 b$ I$ a3 ]" r6 M: j& M
9.     Animal *pa = &d;
   
10. 
    
11.     // 传递父类指针，将会调用子类中实现的虚函数。
    & d8 q. w& N8 A4 b
12.     Animal_Say(pa);
    
13. }

复制代码

  r# R  S. i8 Q6 E/ Q

内存模型如下:

对象d中，从父类继承而来的虚表指针vptr，所指向的虚表是dog_vtbl。

在执行Animal_Say(pa)的时候，虽然参数类型是指向父类Animal的指针，但是实际传入的pa是一个指向子类Dog的对象，这个对象中的虚表指针vptr指向的是子类中自己定义的虚表dog_vtbl，这个虚表中的函数指针say指向的是子类中重新定义的虚函数_Dog_Say，因此this->vptr->say(this)最终调用的函数就是_Dog_Say。

基本上，在C中面向对象的开发思想就是以上这样。这个代码很简单，自己手敲一下就可以了。如果想偷懒，请在后台留言，我发给您。

六、C面向对象思想在项目中的使用
" n! B* B0 ?; w0 O1. Linux内核

看一下关于socket的几个结构体：

1. 
   5 C& ^! J8 w! {
2. struct sock {
   
3.     ...
   / r( B2 G2 m9 V
4. }
   + d: ?6 U1 `1 m. G
5. 
   
6. struct inet_sock {
   
7.     struct sock sk;
   2 F# p1 @. k! B) D& f9 o
8.     ...
   , ?0 d* b: f0 ]' ~* W
9. };
   8 C9 Q9 z( n2 u( D5 ^# U
10. 
    
11. struct udp_sock {
    
12.     struct sock sk;
    
13.     ...
    
14. };

复制代码

sock可以看作是父类，inet_sock和udp_sock的第一个成员都是是sock类型，从内存模型上看相当于是继承了sock中的所有属性。

2. glib库

以最简单的字符串处理函数来举例：

1. 
   & {/ `  g) s& t9 Q
2. GString *g_string_truncate(GString *string, gint len)
   - N' v. n3 {! q5 |' D4 e; x' i! S
3. GString *g_string_append(GString *string, gchar *val)
   
4. GString *g_string_prepend(GString *string, gchar *val)

复制代码

$ g3 q& G9 E) P0 M/ r. ]3 N

API函数的第一个参数都是一个GString对象指针，指向需要处理的那个字符串对象。

1. 
   / I3 X1 E  p: P) k
2. GString *s1, *s2;
   
3. s1 = g_string_new("Hello");
   
4. s2 = g_string_new("Hello");
   
5. 
   $ A+ g. R+ @# q+ h: U. j
6. g_string_append(s1," World!");
   # F* l7 w* S( b) Y" o# ^: O
7. g_string_append(s2," World!");

复制代码

3. 其他项目

还有一些项目，虽然从函数的参数上来看，似乎不是面向对象的，但是在数据结构的设计上看来，也是面向对象的思想，比如：

1. Modbus协议的开源库libmodbus
- Y3 C; q1 ~- s2. 用于家庭自动化的无线通讯协议ZWave
! k* G- @( P0 t( y3. 很久之前的高通手机开发平台BREW

* f: z- ~% b2 m: A
) l. w  v* Q! F+ Q

有参考意义