解释区分一下C语言和OOP
我们经常说C语言是面向过程的&＃xff0c;而C&＃xff0b;&＃xff0b;是面向对象的&＃xff0c;然而何为面向对象&＃xff0c;什么又是面向过程呢&＃xff1f;不管怎么样&＃xff0c;我们最原始的目标只有一个就是实现我们所需要的功能&＃xff0c;从这一点说它们是殊途同归的。过程与对象只是侧重点不同而已。
举个例子吧&＃xff0c;我现在有个计划&＃xff0c;要去北京&＃xff0c;OOP语言是直接给你一个车&＃xff0c;然后你自己设定路线去北京就好&＃xff0c;而C语言是需要你自己制造零件&＃xff0c;自己组装好车&＃xff0c;然后再自己设定路线&＃xff0c;最后到达北京。C语言比较费劲&＃xff0c;但是程序的效率很高。
过程&对象&＃xff1f;
一个对象就是由或多或少的针对这个对象的过程构成的&＃xff0c;当然其中是少不了必要的属性。
一个过程是针对一个或者是多个对象所进行的操作。两者是可以互相转换的&＃xff0c;关键是哪一种方式更能适合你现在的需求&＃xff0c;更能让你的软件开发锦上添花。
我个人认为一般情况下&＃xff0c;一个更容易扩展、维护的软件通常采用的是OOP的思想&＃xff0c;添加一个原本不存在的相对无关单独的个体&＃xff0c;总比在一个已经存在的过程内硬塞进去一个对象要简单&＃xff1b;而且面向过程更容易导致混乱的维护。
举个例子&＃xff0c;同样是一条河与一个湖泊&＃xff0c;哪一个更容管理维护呢&＃xff1f;我想答案是显而易见的。当然不管怎么样&＃xff0c;软件本身设计架构的好坏也是非常重要的。
C语言的特性&＃xff0c;实现OOP
C是一门面向过程的语言&＃xff0c;但它依旧可以实现大多数面向对象所能完成的工作。比如面向对象的三大特性&＃xff1a;封装、继承、多态。我们以下图来写代码举例子。
封装
由于面象向对象是将数据与方法封装到一个类里。使用者无需关心类是怎么实现的。在 C_OOP 中贯彻了这一思想&＃xff0c;C中有一种复杂的数据结构叫做struct。struct是C里面的结构体。
如上图假如我们要对鸟bird进行封装&＃xff0c;bird可能包括姓名、颜色、栖息地、重量、属性等信息。我们就可以对它封装如下&＃xff1a;
struct Bird{
char name[20];//姓名
char color; //颜色
char addr[30]; //栖息地
int weight; //体重
int other; //属性
};
当我们要像OOP那样新建一个对象时&＃xff0c;我们就可以&＃xff1a;
struct Bird p;
我们就可以直接对p进行赋值&＃xff1a;
p.name &＃61; "bird";
p.color &＃61; &＃39;b&＃39;; //&＃39;b&＃39; &＃61; black; &＃39;g&＃39; &＃61; green
p.addr &＃61; &＃39;w&＃39;;
p.weight &＃61; 175;
p.other &＃61; 1;
继承
在常见用C语言实现继承的机制中&＃xff0c;多半是用结构体组合实现的&＃xff0c;同样利用struct&＃xff0c;我们来创建一个Bird结构&＃xff0c;同时继承结构体Bird&＃xff0c;如下&＃xff1a;
struct fBird{
struct Bird p;
char fly[20]; //飞翔
int scream; //鸣叫
};
对Bird进行创建对象&＃xff0c;并赋值&＃xff1a;
struct fBird s;
s.p.name &＃61; "bird";
s.p.color &＃61; &＃39;b&＃39;;
s.p.other &＃61; 25;
s.p.weight &＃61; 65;
s.fly &＃61; "0618";
s.scream &＃61; 90;
多态
C_OOP中的一个核心就是多态&＃xff0c;C中对于多态的实现可以借助函数指针来实现。为了简单起见&＃xff0c;我们假设Bird这个结构体中&＃xff0c;只有一个函数指针。
struct Bird{
void (*print)(void *p);
};
struct fBird{
struct Bird p;
};
而Bird和fBird这两个结构体的print函数实现如下&＃xff1a;
void printBird(void *Bird){
if(NULL &＃61;&＃61; Bird)
return ;
struct Bird *p &＃61; (struct Bird *)Bird;
printf("run in the Bird!!\n");
}
void printfBird(void *Bird){
if(NULL &＃61;&＃61; Bird)
return ;
struct Bird *p &＃61; (struct Bird *)Bird;
printf("run in the fBird!!\n");
}
我们写一个函数来调用他们&＃xff1a;
void print(void *Bird){
if(NULL &＃61;&＃61; Bird)
return ;
struct Bird *p &＃61; (struct Bird *)Bird;
p->print(Bird);
}
int main(){
struct Bird bird;
struct fBird fbird;
Bird.print &＃61; printBird;
fBird.p.print &＃61; printfBird;
print(&bird); //实参为Bird的对象
print(&fbird); //实参为fBird的对象
return 0;
}
他们的输出为&＃xff1a;
run in the Bird!!
run in the fBird!!
其实这个也不难理解&＃xff0c;无论是fBird还是Bird&＃xff0c;他们在内存中只有一个变量&＃xff0c;就是那个函数指针&＃xff0c;而void表示任何类型的指针&＃xff0c;当我们将它强制转换成struct Bird类型时&＃xff0c;p->print指向的自然就是传入实参的print地址。
OOP真的那么重要&＃xff1f;
从大学到工作至今&＃xff0c;在嵌入式领域中一直是使用C语言&＃xff0c;而我在学习C&＃xff0b;&＃xff0b;的过程中&＃xff0c;看的代码越多&＃xff0c;代码量越大&＃xff0c;越来越觉得C&＃xff0b;&＃xff0b;对于大型软件架构的良好可控性&＃xff0c;和对以后程序员维护代码时良好的可读性&＃xff1b;
个人认为&＃xff1a;C语言中最大的成功在于它的指针&＃xff0c;但是也是最容易出错的&＃xff0c;想要理解C&＃xff0c;必须要掌握指针。虽然说&＃xff0c;语言只是一门工具&＃xff0c;但是这是基础.
或者你可以说C太底层&＃xff0c;现在都是OOP的时代了&＃xff0c;谁还会用面向过程的,你们不要忘了操作系统是用什么写的&＃xff1f;是C&＃xff1b;C实现的nginx的并发量是C&＃43;&＃43;实现的apache的几十倍,关键是要理解语言背后的思想。
当然这不是为了OOP而OOP&＃xff0c;实在是OOP的一些特征&＃xff0c;例如封装&＃xff0c;多态其实是软件工程思想&＃xff0c;这些思想不分语言&＃xff0c;遵循了这些思想可以使得程序更有弹性&＃xff0c;更易修改和维护&＃xff0c;避免僵化&＃xff0c;脆弱的性质。
嵌入式C语言使用OOP的一些思考
然而就目前来说&＃xff0c;在嵌入式领域广泛的使用C&＃xff0b;&＃xff0b;显然是不现实的事情。在一个到处是OOP的年代&＃xff0c;为何面向过程的C语言依然可以如此活跃&＃xff1f;
我们可以用它来开发一系列的小工具&＃xff0c;Unix/Linux就是由这些小工具组成的操作系统&＃xff1b;同时用C语言可以开发高性能的应用程序。
C语言良好的可移植性&＃xff0c;小巧灵活&＃xff0c;而且还有一个直接与硬件打交道的指针的存在&＃xff0c;对内存等良好的操作性以及执行之速度快&＃xff0c;是嵌入式开发唯有的高级语言&＃xff0c;均是一般嵌入式产品的不二首选。
LW_OOPC->C语言的面对对象
LW_OOPC是台湾的MISOO团队根据多年研发经验&＃xff0c;总结出来的一种轻便的面向对象的C语言。虽然不足以提供足够的能力使我们实现面向对象所有的概念&＃xff0c;但是我们依然可以应用它们完成我们简单的面向对象思想的构建。
lw_oopc仅用了2个文件&＃xff0c;.h及.c文件就实现了面向对象的三大因素&＃xff0c;实现过程极为简洁又富含技巧。lw_oopc说白了&＃xff0c;就是定义了一堆宏&＃xff0c;使用起来也就是调用这些宏。
//| 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概述
简单来说它主要是一个头文件&＃xff0c;我们通过对这个头文件的使用来实现面向对象。
//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 &＃61; (struct type*)malloc(sizeof(struct type));
#define CTOR2(type, type2) /
void* type2##New() /
{ /
struct type *t; /
t &＃61; (struct type*)malloc(sizeof(struct type));
#define END_CTOR return (void*)t; }
#define FUNCTION_SETTING(f1, f2) t->f1 &＃61; 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 &＃61; 0.0;
Circle *pc;
pc &＃61; (Circle*)CircleNew();
area &＃61; pc->cal_area(10);
printf("area &＃61; %f/n", area);
return 0;
}
接口的实现
在OOP程序中&＃xff0c;通常是通过类定义和接口定义来实现的。
//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 &＃61; (Circle*)circle;
_this->radius &＃61; radius;
}
static double circle_cal_area(void* circle)
{
Circle *_this &＃61; (Circle*)circle;
return PI*_this->radius*_this->radius;
}
static double circle_cal_permimeter(void* circle)
{
Circle *_this &＃61; (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 &＃61; %f/n", pi->cal_area(pi));
}
int main()
{
IA *pc &＃61; NULL;
pc &＃61; (IA*)CircleNew();
pc->init(pc, 10.0);
print_area();
return 0;
}
总结
语言只是一种工具&＃xff0c;任何语言之间都是相通的&＃xff0c;一通则百通&＃xff0c;关键是要理解语言背后的思想&＃xff0c;理解其思想&＃xff0c;任何语言&＃xff0c;拿来用就行了。语言没有好坏之分&＃xff0c;任何语言既然存在自然有它存在的价值。
推荐好文 点击蓝色字体即可跳转
☞ 专辑|Linux应用程序编程大全
☞ 专辑|手撕C语言
在公众号聊天界面回复关键词"666"&＃xff0c;小哥免费发放技术资料供大家学习研究&＃xff01;
长按前往图中包含的公众号关注
京公网安备 11010802041100号