如何把C++的源程序改写成C语言

Posted 2021-04-25 信盈达分享汇

tags:

篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了如何把C++的源程序改写成C语言相关的知识，希望对你有一定的参考价值。

由于C＋＋解释器比C语言解释器占用的存储空间要大500k左右。为了节省有限的存储空间，降低成本，同时也为了提高效率，将用C＋＋语言写的源程序用C语言改写是很有必要的。

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

方法有两种：

第一种是将C＋＋中的面向对象特征去掉，先全部理解源代码的逻辑，然后改写；

第二种是在C中保留面向对象的部分特征，用结构体实现类的功能。

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

hpijs程序中类有140多个，这个时候就需要采用第二个方法了，你可以一个类一个类的改没有什么太高的难度，如果不是笔误的话，几乎不会出错，而且根本不需要理解程序逻辑，也许改完后你对程序所要实现的功能还一无所知。

倒不是说一无所知对大家有好处，只是想说这种方法的与程序逻辑本身的无关性。

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

说明：

函数Ixx为类xx的构造函数的实现。

原类的成员函数改为前缀为结构体名＋‘_’的函数。

函数指针U为原类的析构函数的声明；

U＋结构体名称为原类的析构函数的实现；

Fun-_+结构体名为对该结构体成员函数指针进行指向；

以后遇到上述情况将不再说明。

一

类的成员函数和数据成员

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

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

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

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

二

类的构造函数

类在实例化的时候会调用类的缺省构造函数，在struct里，要定义一个同名函数指针指向一个具有构造函数功能的初始化函数，与构造函数不同的是，要在初始化函数里加入进行函数指针初始化的语句。

使用的时候在创建结构体变量的时候要用malloc而不是new，并且这个时候要手工调用初始化函数。

如下例所示：

 
   
   
 
  
    
    
  class A
 
   
   
 
 
   
   
 
  
    
    
  {
 
   
   
 
 
   
   
 
  
    
    
  public:
 
   
   
 
 
   
   
 
  
    
    
  A();
 
   
   
 
 
   
   
 
  
    
    
  ~A();
 
   
   
 
 
   
   
 
  
    
    
  void func(int a);
 
   
   
 
 
   
   
 
  
    
    
  private:
 
   
   
 
 
   
   
 
  
    
    
  int b;
 
   
   
 
 
   
   
 
  
    
    
  };
 
   
   
 
 
   
   
 
  
    
    
  A::A()
 
   
   
 
 
   
   
 
  
    
    
  {
 
   
   
 
 
   
   
 
  
    
    
  b=0;
 
   
   
 
 
   
   
 
  
    
    
  }
 
   
   
 
 
   
   
 
  
    
    
  void A：：func(int a)
 
   
   
 
 
   
   
 
  
    
    
  {
 
   
   
 
 
   
   
 
  
    
    
  b=a;
 
   
   
 
 
   
   
 
  
    
    
  }
 
   
   
 
 
   
   
 
  
    
    
  typedef struct classA A;
 
   
   
 
 
   
   
 
  
    
    
  struct classA
 
   
   
 
 
   
   
 
  
    
    
  {
 
   
   
 
 
   
   
 
  
    
    
  void (*A)(struct classA *p);//构造函数指针
 
   
   
 
 
   
   
 
  
    
    
  void (*U)(struct classA *p);//析构函数指针
 
   
   
 
 
   
   
 
  
    
    
  void (*func)(struct classA *p,int a);
 
   
   
 
 
   
   
 
  
    
    
  int b;
 
   
   
 
 
   
   
 
  
    
    
  };
 
   
   
 
 
   
   
 
  
    
    
  void fun_A(A *p)
 
   
   
 
 
   
   
 
  
    
    
  {
 
   
   
 
 
   
   
 
  
    
    
  p->func=classA_func; //将函数指针初始化
 
   
   
 
 
   
   
 
  
    
    
  }
 
   
   
 
 
   
   
 
  
    
    
  void IA(A *p) //构造函数，命名规则在类名前加I
 
   
   
 
 
   
   
 
  
    
    
  {
 
   
   
 
 
   
   
 
  
    
    
  fun_A(p);
 
   
   
 
 
   
   
 
  
    
    
  p->b=0; //原构造函数所作部分
 
   
   
 
 
   
   
 
  
    
    
  }
 
   
   
 
 
   
   
 
  
    
    
  void classA_func(A *p,int a)
 
   
   
 
 
   
   
 
  
    
    
  {
 
   
   
 
 
   
   
 
  
    
    
  p->b=a;
 
   
   
 
 
   
   
 
  
    
    
  }

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

 
   
   
 
  
    
    
  A *s=(A*)malloc(sizeof(A));
 
   
   
 
 
   
   
 
  
    
    
  s->A=IA;
 
   
   
 
 
   
   
 
  
    
    
  s->A(s);

三

类的析构函数

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

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

如果将子类指针赋给基类指针，基类指针在释放的时候不必考虑调用哪个函数名的析构函数，只需调用成员函数U即可。

成员函数U需要像一般成员函数一样在fun_类名()函数中指定。类的析构函数是由系统调用的，在C中则要显式调用。至于何时调用，要准确判断。

四

类的拷贝构造函数

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

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

作为函数返回值。

实例化类时作参数。

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

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

由于C中定义struct变量的时候，使用的全部是指针，不会用到拷贝构造函数，所以暂不考虑。

对于原来函数参数或者返回值需要类变量的，要全部转化为类指针的方式。实例化类时作参数的情况，可以通过另外定义一个带参数的构造函数来解决。

五

类的内联函数和虚函数

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

 
   
   
 
  
    
    
  class B
 
   
   
 
 
   
   
 
  
    
    
  {
 
   
   
 
 
   
   
 
  
    
    
  …
 
   
   
 
 
   
   
 
  
    
    
  virture void funb();
 
   
   
 
 
   
   
 
  
    
    
  inline int add()const {return a+b;};
 
   
   
 
 
   
   
 
  
    
    
  private:
 
   
   
 
 
   
   
 
  
    
    
  int a;
 
   
   
 
 
   
   
 
  
    
    
  int b;
 
   
   
 
 
   
   
 
  
    
    
  …
 
   
   
 
 
   
   
 
  
    
    
  }

改为：

 
   
   
 
  
    
    
  typedef classB B;
 
   
   
 
 
   
   
 
  
    
    
  struct classB
 
   
   
 
 
   
   
 
  
    
    
  {
 
   
   
 
 
   
   
 
  
    
    
  …
 
   
   
 
 
   
   
 
  
    
    
  void (*funb)(struct classB *p);
 
   
   
 
 
   
   
 
  
    
    
  int (*add)(struct classB *p);
 
   
   
 
 
   
   
 
  
    
    
  int a;
 
   
   
 
 
   
   
 
  
    
    
  int b;
 
   
   
 
 
   
   
 
  
    
    
  }
 
   
   
 
 
   
   
 
  
    
    
  void classB_funb(B *p)
 
   
   
 
 
   
   
 
  
    
    
  {
 
   
   
 
 
   
   
 
  
    
    
  …
 
   
   
 
 
   
   
 
  
    
    
  }
 
   
   
 
 
   
   
 
  
    
    
  int classB_add(B *p)
 
   
   
 
 
   
   
 
  
    
    
  {
 
   
   
 
 
   
   
 
  
    
    
  return p->a+p->b;
 
   
   
 
 
   
   
 
  
    
    
  }
 
   
   
 
 
   
   
 
  
    
    
  void fun_classB(B *p)
 
   
   
 
 
   
   
 
  
    
    
  {
 
   
   
 
 
   
   
 
  
    
    
  …
 
   
   
 
 
   
   
 
  
    
    
  p->funb=classB_funb;
 
   
   
 
 
   
   
 
  
    
    
  p->add= classB_add;
 
   
   
 
 
   
   
 
  
    
    
  }