解釋區分一下C語言和OOP

我們經常說C語言是面向過程的，而C＋＋是面向對象的，然而何為面向對象，什么又是面向過程呢？不管怎么樣，我們最原始的目標只有一個就是實現我們所需要的功能，從這一點說它們是殊途同歸的。過程與對象只是側重點不同而已。

舉個例子吧，我現在有個計劃，要去北京，OOP語言是直接給你一個車，然后你自己設定路線去北京就好，而C語言是需要你自己制造零件，自己組裝好車，然后再自己設定路線，最后到達北京。C語言比較費勁，但是程序的效率很高。

過程&對象？

一個對象就是由或多或少的針對這個對象的過程構成的，當然其中是少不了必要的屬性。

一個過程是針對一個或者是多個對象所進行的操作。兩者是可以互相轉換的，關鍵是哪一種方式更能適合你現在的需求，更能讓你的軟件開發錦上添花。

我個人認為一般情況下，一個更容易擴展、維護的軟件通常采用的是OOP的思想，添加一個原本不存在的相對無關單獨的個體，總比在一個已經存在的過程內硬塞進去一個對象要簡單；而且面向過程更容易導致混亂的維護。

舉個例子，同樣是一條河與一個湖泊，哪一個更容管理維護呢？我想答案是顯而易見的。當然不管怎么樣，軟件本身設計架構的好壞也是非常重要的。

C語言的特性，實現OOP

C是一門面向過程的語言，但它依舊可以實現大多數面向對象所能完成的工作。比如面向對象的三大特性：封裝、繼承、多態。我們以下圖來寫代碼舉例子。

封裝

由于面象向對象是將數據與方法封裝到一個類里。使用者無需關心類是怎么實現的。在 C_OOP 中貫徹了這一思想，C中有一種復雜的數據結構叫做struct。struct是C里面的結構體。

如上圖假如我們要對鳥bird進行封裝，bird可能包括姓名、顏色、棲息地、重量、屬性等信息。我們就可以對它封裝如下： 

struct Bird{  
    char name[20];//姓名  
    char color;    //顏色     
    char addr[30];    //棲息地  
    int weight;        //體重  
    int other;      //屬性  
}; 

當我們要像OOP那樣新建一個對象時，我們就可以： 

struct Bird p; 

我們就可以直接對p進行賦值： 

p.name = "bird";  
p.color = 'b';  //'b' = black; 'g' = green  
p.addr = 'w';    
p.weight = 175;  
p.other = 1; 

繼承

在常見用C語言實現繼承的機制中，多半是用結構體組合實現的，同樣利用struct，我們來創建一個Bird結構，同時繼承結構體Bird，如下： 

struct fBird{  
    struct Bird p;  
    char fly[20]; //飛翔  
    int scream;        //鳴叫  
}; 

對Bird進行創建對象，并賦值： 

struct fBird s;  
s.p.name = "bird";  
s.p.color = 'b';  
s.p.other = 25;  
s.p.weight = 65;  
s.fly = "0618";  
s.scream = 90; 

多態

C_OOP中的一個核心就是多態，C中對于多態的實現可以借助函數指針來實現。為了簡單起見，我們假設Bird這個結構體中，只有一個函數指針。 

struct Bird{  
    void (*print)(void *p);  
};  
struct fBird{  
    struct Bird p;  
}; 

而Bird和fBird這兩個結構體的print函數實現如下： 

void printBird(void *Bird){  
    if(NULL == Bird)  
        return ;  
    struct Bird *p = (struct Bird *)Bird;  
    printf("run in the Bird!!\n");  
}  
void printfBird(void *Bird){  
    if(NULL == Bird)  
        return ;  
    struct Bird *p = (struct Bird *)Bird;  
    printf("run in the fBird!!\n");  
} 

我們寫一個函數來調用他們： 

void print(void *Bird){  
    if(NULL == Bird)  
        return ;  
    struct Bird *p = (struct Bird *)Bird;  
    p->print(Bird);  
}  
int main(){  
    struct Bird bird;  
    struct fBird fbird;  
    Bird.print = printBird;  
    fBird.p.print = printfBird;  
    print(&bird);    //實參為Bird的對象  
    print(&fbird);  //實參為fBird的對象  
    return 0;  
} 

他們的輸出為： 

run in the Bird!!  
run in the fBird!! 

其實這個也不難理解，無論是fBird還是Bird，他們在內存中只有一個變量，就是那個函數指針，而void表示任何類型的指針，當我們將它強制轉換成struct Bird類型時，p->print指向的自然就是傳入實參的print地址。

OOP真的那么重要？

從大學到工作至今，在嵌入式領域中一直是使用C語言，而我在學習C＋＋的過程中，看的代碼越多，代碼量越大，越來越覺得C＋＋對于大型軟件架構的良好可控性，和對以后程序員維護代碼時良好的可讀性；

個人認為：C語言中最大的成功在于它的指針，但是也是最容易出錯的，想要理解C，必須要掌握指針。雖然說，語言只是一門工具，但是這是基礎.

或者你可以說C太底層，現在都是OOP的時代了，誰還會用面向過程的,你們不要忘了操作系統是用什么寫的？是C；C實現的nginx的并發量是C++實現的apache的幾十倍,關鍵是要理解語言背后的思想。

當然這不是為了OOP而OOP，實在是OOP的一些特征，例如封裝，多態其實是軟件工程思想，這些思想不分語言，遵循了這些思想可以使得程序更有彈性，更易修改和維護，避免僵化，脆弱的性質。

嵌入式C語言使用OOP的一些思考

然而就目前來說，在嵌入式領域廣泛的使用C＋＋顯然是不現實的事情。在一個到處是OOP的年代，為何面向過程的C語言依然可以如此活躍？

我們可以用它來開發一系列的小工具，Unix/Linux就是由這些小工具組成的操作系統；同時用C語言可以開發高性能的應用程序。

C語言良好的可移植性，小巧靈活，而且還有一個直接與硬件打交道的指針的存在，對內存等良好的操作性以及執行之速度快，是嵌入式開發唯有的高級語言，均是一般嵌入式產品的不二首選。

LW_OOPC->C語言的面對對象

LW_OOPC是臺灣的MISOO團隊根據多年研發經驗，總結出來的一種輕便的面向對象的C語言。雖然不足以提供足夠的能力使我們實現面向對象所有的概念，但是我們依然可以應用它們完成我們簡單的面向對象思想的構建。

lw_oopc僅用了2個文件，.h及.c文件就實現了面向對象的三大因素，實現過程極為簡潔又富含技巧。lw_oopc說白了，就是定義了一堆宏，使用起來也就是調用這些宏。 

//| INTERFACE                 | 接口  
//----------------------------------------------------------------------  
//| CLASS                     | 類  
//----------------------------------------------------------------------  
//| CTOR                      | 構造器開始  
//----------------------------------------------------------------------   
//| END_CTOR                  | 構造器截止  
//----------------------------------------------------------------------  
//| FUNCTION_SETTING          | 關聯成員函數指針  
//----------------------------------------------------------------------  
//| IMPLEMENTS                | 繼承  
//----------------------------------------------------------------------  
//| DTOR                      | 為了支持析構函數的概念  
//| END_DTOR                  |                                                
//----------------------------------------------------------------------  
//| ABS_CLASS                 | 為了支持抽象類的概念     
//----------------------------------------------------------------------  
//| ABS_CTOR                  | 為了支持可繼承的抽象類的構造函數  
//| END_ABS_CTOR              |                           
//----------------------------------------------------------------------  
//| EXTENDS                   | 為了讓熟悉Java的人容易理解（與IMPLEMENTS宏等同）    
//----------------------------------------------------------------------  
//| SUPER_CTOR                | 為了支持子類調用父類的構造函數  
//----------------------------------------------------------------------  
//| SUPER_PTR                 | 為了支持向上轉型       
//| SUPER_PTR_2               |       
//| SUPER_PTR_3               |   
//----------------------------------------------------------------------  
//| SUB_PTR                   | 為了支持向下轉型     
//| SUB_PTR_2                 |                         
//| SUB_PTR_3                 |                                          
//----------------------------------------------------------------------  
//| INHERIT_FROM              | 為了支持訪問直接父類的數據成員  
//---------------------------------------------------------------------- 

下面是對LW_OOPC的簡單的分析。

LW_OOPC概述

簡單來說它主要是一個頭文件，我們通過對這個頭文件的使用來實現面向對象。 

//lw_oopc.h : MISOO團隊設計的C宏  
#include  
#ifndef LW_OOPC  
#define LW_OOPC  
#define CLASS(type)       /  
typedef struct type type; /  
struct type  
#define CTOR(type)        /  
void* type##New()         /  
{                         /  
  struct type *t;        /  
  t = (struct type*)malloc(sizeof(struct type));  
#define CTOR2(type, type2)     /  
void* type2##New()             /  
{                              /  
  struct type *t;             /  
  t = (struct type*)malloc(sizeof(struct type));    
#define END_CTOR return (void*)t; }  
#define FUNCTION_SETTING(f1, f2) t->f1 = f2;  
#define IMPLEMENTS(type) struct type type  
#define INTERFACE(type) struct type  
#endif  
/*          lw_oopc.h               */ 

下面一段代碼是簡單的OOPC的應用: 

// Circle.c     
#include  
#include "lw_oop.h"  
#define PI 3.1415926  
CLASS(Circle)  
{  
  double (*cal_area)(double);  
}  
double circle_cal_area(double radius)  
{  
  return PI*r*r;  
}  
CTOR(Circle) 
  FUNCTION_SETTING(cal_area, circle_cal_area)  
END_CTOR  
int main()  
{  
     double area = 0.0;  
     Circle *pc;   
      pc = (Circle*)CircleNew();  
     area = pc->cal_area(10);  
     printf("area = %f/n", area);  
     return 0;  
} 

接口的實現

在OOP程序中，通常是通過類定義和接口定義來實現的。 

//IA.h    
#include "lw_oopc.h"  
INTERFACE(IA)  
{  
   void   (*init)(void*, double);  
   double (*cal_area)(void*);  
   double (*cal_permimeter)(void*);  
}  

//circle.c   
#include "IA.h"  
#define PI 3.1415926  
CLASS(Circle)  
{  
  IMPLEMENTS(IA);  
  double radius;  
}  
static void circle_init(void* circle, double radius) 
{  
  Circle *_this = (Circle*)circle;  
  _this->radiusradius = radius;  
}  
static double circle_cal_area(void* circle)  
{  
  Circle *_this = (Circle*)circle;  
  return PI*_this->radius*_this->radius;  
}  
static double circle_cal_permimeter(void* circle)  
{  
  Circle *_this = (Circle*)circle;  
  return 2*PI*_this->radius;  
}  
CTOR(Circle)  
  FUNCTION_SETTING(IA.init, circle_init)  
  FUNCTION_SETTING(IA.cal_area, circle_cal_area)  
  FUNCTION_SETTING(IA.cal_permimeter, circle_cal_permimeter)  
END_CTOR  

//main.c  
#include  
#include “IA.h”  
void print_area(IA* pi)  
{  
    printf("area = %f/n", pi->cal_area(pi));  
}  
int main()  
{  
  IA *pc = NULL;  
  pc = (IA*)CircleNew();  
  pc->init(pc, 10.0);  
  print_area();  
  return 0;  
} 

總結

語言只是一種工具，任何語言之間都是相通的，一通則百通，關鍵是要理解語言背后的思想，理解其思想，任何語言，拿來用就行了。語言沒有好壞之分，任何語言既然存在自然有它存在的價值。