C++解释器比C语言解释器占用的存储空间要大，想要在某些特定场合兼容C++代码，同时为了节省有限的存储空间，降低成本，也为了提高效率，将用C++语言写的源程序用C语言改写是很有必要的。

, o: u0 j/ S* l3 N. \

C++与C区别最大的就是C++中的类的概念和特性，将C++改为C的问题，就转换成如何将类化去的问题。

方法有两种：

• 将C++中的面向对象特征去掉，先全部理解源代码的逻辑，然后改写；
• 是在C中保留面向对象的部分特征，用结构体实现类的功能。
  4 Z) O0 P& e. e4 ]& i( F

3 O  p* W% p2 u5 k7 S第一种方法，对于类的数目很少的情况还可以，如果类的数目比较多，全部理解源代码，然后重写就很耗时间，而且很容易出错，更甚者，如果遇到大的项目想全部理解源代码几乎是不可能的。

下面对C++的一些特性，以及如何在c里实现或者替代，作一些初步的探讨。

说明：

• 函数Ixx为类xx的构造函数的实现。
• 原类的成员函数改为前缀为结构体名＋‘_’的函数。
• 函数指针U为原类的析构函数的声明；
• U＋结构体名称为原类的析构函数的实现；
• Fun-_+结构体名为对该结构体成员函数指针进行指向；
• 以后遇到上述情况将不再说明。
  
  

一．类的成员函数和数据成员

由于struct没有对成员的访问权限进行控制，必须加入额外的机制进行访问控制，这样一来就使得程序复杂化了，所以只能放弃访问权限的控制。

1）对于类的数据成员可以直接转为C中结构体的数据成员。

2 _2 V! @- \, \3 R5 M7 M2 c0 n

2）函数则需转化为对应的函数指针，因为struct里不允许出现函数的声明和定义。而函数前如果有virture，inline等修饰符也要去掉，如函数void funca(int a);改为void (*funca)(struct B *p,int a);大家可以看到函数指针的原型里加了一个指针struct B的指针，这是因为要在函数内部对类的成员进行操作，要靠该指针指定结构体的成员。在类的成员函数里，实际上在参数列里也隐含有一个指向自身的this指针。

3）对于静态成员则要定义成全局变量或全局函数，因为结构体中不能有静态成员。

二．类的构造函数

类在实例化的时候会调用类的缺省构造函数，在struct里，要定义一个同名函数指针指向一个具有构造函数功能的初始化函数，与构造函数不同的是，要在初始化函数里加入进行函数指针初始化的语句.使用的时候在创建结构体变量的时候要用malloc而不是new，并且这个时候要手工调用初始化函数。

# C, b/ a+ j5 C+ j; @% K# t

如下例所示：

1. 
   
2. class A
   
3. {
   3 I7 H; i4 A5 W9 X/ s
4. public:
   4 d0 r4 f( T: g
5.     A();
   
6.     ~A();
   6 M; z3 d( Q8 g( C
7.     void func(int a);
   + B/ s5 T/ v4 E' t6 `  D
8. private:
   
9.     int b;
   ' S3 I( w- U) E6 M. X& p$ f$ l
10. };
    ; N. H" g& q% j& Y+ I
11. A::A()
    1 ?, x! `1 s7 M$ n4 x  O: m/ [
12. {
    " ?; B3 R! V2 S: q' e' z
13.     b=0;
    0 r$ T9 S; z5 |* u" m' E
14. }
    4 S: i2 [( E3 M4 V
15. 
    
16. void A：：func(int a)
    ; }0 ?) `( Q& M
17. {
    
18.     b=a;
    2 L# ?2 K( t0 T- b$ v
19. }
    % O+ g! G3 d) o
20. 
    
21. typedef struct classA A;
    
22. struct classA
    4 F' ~9 S+ A4 \( v: t; M
23. {
    , [% ^" [4 c$ q1 x$ B, S4 ~5 x3 N. Z
24.      void (*A)(struct classA *p);//构造函数指针
    
25.      void (*U)(struct classA *p);//析构函数指针
    ; @! f+ G) ]; K! q7 q
26.      void (*func)(struct classA *p,int a);
    3 [1 P- L7 ^1 N
27.      int b;
    ; n: K) I( l( e; Q* U
28. };
    
29. 
    4 P0 g% p' A! k; I
30. void fun_A(A *p)
    / ~4 s& J/ x" d' j  ~( A+ \
31. {
    
32.      p->func=classA_func; //将函数指针初始化
    # O' S: B( n! b
33. }
    
34. 
    $ P4 y4 X6 \4 V, ?% m& ?6 ?/ h
35. void IA(A *p) //构造函数，命名规则在类名前加I
    
36. {
    
37.      fun_A(p);
    1 s* u* R0 t3 |) N
38.      p->b=0;    //原构造函数所作部分
    0 j; c0 k4 G/ ]$ u3 {
39. }
    
40. 
    " K. I1 V) B& N% V
41. void classA_func(A *p,int a)
    1 V) q2 Z! d: a' d" T
42. {
    
43.     p->b=a;
    
44. }

复制代码

, x+ M2 o) n5 Q# d" z6 e

在使用的地方采用如下方式：

1. 
   
2.   A *s=(A*)malloc(sizeof(A));
   9 w0 Y, h- Q, n  @
3.     s->A=IA;
   
4.     s->A(s);

复制代码

" }. N/ K; r/ W4 o4 U

三．类的析构函数

类的析构函数所作的工作是释放所占的资源。

% L8 V3 P  `4 `% L

在C中，无论是哪个struct都用函数指针U替代析构函数。之所以所有的struct都用指针U是基于如下情况：

如果将子类指针赋给基类指针，基类指针在释放的时候不必考虑调用哪个函数名的析构函数，只需调用成员函数U即可。成员函数U需要像一般成员函数一样在fun_类名()函数中指定。

1 ~& b* d9 y' a9 d1 \, c7 `. A& p

类的析构函数是由系统调用的，在C中则要显式调用。至于何时调用，要准确判断。

四．类的拷贝构造函数

类的拷贝构造函数主要用途是加快以下情况下类的构建速度：

1. 作为参数传给函数。（additem（Itema））

2. 作为函数返回值。

3. 实例化类时作参数。

这三种情况下都是由系统直接调用类的拷贝构造函数而不是构造函数。

注意：C=D；不会调用拷贝构造函数，这种情况下使用的是重载‘＝’运算符的方法。(详见运算符重载);

* s& _/ v" T. a& u1 M, k, E$ j

由于C中定义struct变量的时候，使用的全部是指针，不会用到拷贝构造函数，所以暂不考虑。对于原来函数参数或者返回值需要类变量的，要全部转化为类指针的方式。实例化类时作参数的情况，可以通过另外定义一个带参数的构造函数来解决。

3 s$ h9 ?& w- F2 f: |9 `* o

五．类的内联函数和虚函数

内联函数和虚函数的修饰符inline 、virture 要全部去掉。内联函数体则要去掉，将内联函数在外面定义成一个函数。如：

1. 
   
2. class B
   
3. {
   
4.     …
   ' U4 E+ t; p5 f' \
5.     virture void funb();
   
6.     inline int add()const {return a+b;};
   
7. private:
   5 P: k4 r; a) T( t; z
8.     int a;
   
9.     int b;
   ' i" p& k8 i, S; E  w; P) ~
10.     …
    # A# T9 Q% v% o% [- g
11. }
    8 C  l9 X& B/ f6 p4 `( l- A# ]

复制代码

改为：

1. <font style="background-color:rgb(255, 255, 255)"><font face="Tahoma"><font color="black">
   & ]( d) J+ X; R6 Z! a# p2 j
2. typedef classB B;
   
3. struct classB
   
4. {
   
5.     …
   ' ?6 A' ]7 `8 g. C- j
6.     void (*funb)(struct classB *p);
   
7.     int (*add)(struct classB *p);
   ! U  m2 K4 q) A7 N
8.     int a;
   
9.     int b;
   
10. }
    8 V* H  z6 {/ @1 @4 ?! T" d
11. 
    
12. void classB_funb(B *p)
      `$ `4 E+ n/ O0 P: G& S' H
13. {
    
14.      …
    
15. }
    . Y: |  o7 o; e( t" K# U- d7 v
16. 
    9 O4 V- T. H& C: f2 |$ J
17. int classB_add(B *p)
    
18. {
    
19.      return p->a+p->b;
    7 S+ o5 ?+ I) t
20. }
    
21. 
    6 V1 A3 X8 W0 ^: `1 A# m, p% V) h: i7 I
22. void fun_classB(B *p)
    ) T, M: Y# _* I5 s" T1 \, J7 i# Y
23. {
    
24.      …
    
25.      p->funb=classB_funb;
    
26.      p->add= classB_add;
    
27. }</font></font></font>
    2 \" Y2 a# X3 t2 A

复制代码

/ ]/ ], X+ P3 M0 \3 j% r

六．重载

类中重载有函数重载和运算符重载两种：

" J5 y5 ~8 ]$ _* {

1）函数的重载

函数重载满足的条件是：函数名相同，参数个数或者参数类型不同。

这样在调用的时候，会根据你输入的参数不同，调用不同的函数。

在C中只好分别起不同的名字，没有别的解决办法。

2）运算符重载

运算符重载只是为了满足一般的运算符使用的习惯而又不会出现错误。

C中不支持运算符重载，可以定义一个函数实现该功能。

这是一般类的修改。

6 u5 T- Y  h$ C# J% p+ Y

七．类的继承

1）单继承

如果类之间有继承关系，先将基类按照一般类的改法，修改好。然后将基类的定义部分全部拷到子类的前头。除了将基类的构造函数名改为子类构造函数名外，不可以将基类定义的部分作其他改动。并在构造函数里调用基类的构造函数，然后如果子类覆盖了基类的函数，则要把该函数指针重定向到子类函数。这是为了保持类的继承带来的动态联编的特性。

类之间的继承关系是复杂且多变的，为了保证基类在所有子类中的唯一而且方便修改，最好的方法就是把基类的结构体部分做成宏，在子类中直接使用即可。

# u3 l+ [) |2 {! k" y

2）多继承

我个人认为多继承是最好不要用，他会带来一些问题，会出现多个继承路径的问题。除非是为了方便编程而使用的，如继承接口等等。

8 ^7 `$ N' I/ m" |5 V- e/ L

多继承也是可以改的，将多个基类的成员全部拷到子类里，遇到重复的成员名，则在前面加上前缀来区别，当然这个指的是基类之间有相同的，如果是派生类和基类之间有重名的，则会覆盖基类。

八．其他

以上就是C++中主要的与C的区别最大而且最常用的特性及修改方法。其他的还有一些比如模板的使用等等，这些都是为了方便编程，复用代码。C中没有，只好自己写多个函数来分别实现。另外还有参数列表里的&符号要用指针替代，缺省值也要去掉，而在调用的时候要注意将缺省值写上。