C和指针-优快云博客

前言

指针是C的灵魂，正是指针使得C存在了这么多年，而且将长期存在下去。事实上，我自己不用C语言写程序已经有一年了，工作中接触到的只有java,python和javascript。最近用C完成了一下类似于OO中的封装(即"类")的概念，顺便把指针复习了下，感觉有必要记一下。

本文中的例子有这样两个概念：任务(Task)，执行器(Executor)。任务有名称(taskName)，并且可以执行(execute)。而执行器与具体任务所执行的内容无关，只是回调(callback)任务的执行方法，这样我们的执行器就可以做的比较通用。而任务接口只需要实现一个execute方法即可，这样我们的任务就可以是多种多样的，可以通过统一的接口set给执行器执行。这是面向对象中基本的思想，也是比较常用的抽象方式。下面我们具体看下例子。

可以想象，main函数大概是这个样子：

int main( int argc, char ** argv) {

    Task * t1 = TaskConstruction( " Task1 " , run);//此处的run是一个函数指针
    Executor * exe = ExecutorConstruction();
    exe -> setTask(t1);
    exe -> begin();
    exe -> cancel();

    Task * t2 = TaskConstruction( " Task2 " , run2);//此处的run2也是一个函数指针，用于构造一个Task.
    exe -> setTask(t2);
    exe -> begin();
    exe -> cancel();

     return (EXIT_SUCCESS);
}

运行结果为：

task : [Task1] is ready to run
[a = 1.200000 , b = 2.300000 ]
[(a + b) * (a - b) = - 3.850000 ]
cancel is invoked here
task : [Task2] is ready to run
another type of execute,just print out some information
cancel is invoked here

好了，下面详细看看实现：

定义接口

首先，定义Task和Executor两个实体的接口：

Task接口，注意其中的_this字段，这个指针在后边有很重要的作用，用于hold整个Task的实例。然后是一个taskName的字符串，和一个函数指针，这个指针在初始化(构造)Task时传入。这个execute()函数比较有意思，它不在内部使用，而是让执行器回调执行的。

#ifndef _ITASK_H
#define     _ITASK_H

typedef struct Task{
     struct Task * _this;
     char * taskName;
     void ( * execute)();
}Task;

void execute();
#endif     /* _ITASK_H */

执行器接口比Task接口复杂一些，其中包含_this指针，包含一个对Task的引用，然后是对外的接口begin(), cancel().对接口的使用者来说，他们只需要调用接口实例上的setTask(),将任务传递给执行器，然后在适当时期调用begin(),等待任务正常结束或者调用cancel()将其取消掉。

#include "ITask.h"

#ifndef _IEXECUTOR_H
#define    _IEXECUTOR_H

typedef struct Executor{
    struct Executor *_this;
    Task *task;
    char *(*setTask)(Task* task);
    void (*begin)();
    void (*cancel)();
}Executor;

char *setTask(Task *task);
void begin();
void cancel();

#endif /* _IEXECUTOR_H */

实现接口

#include < stdlib.h >
#include " ITask.h "

Task * task = NULL;

void execute();

/*
* The construction of Task object.
* name : the name of the task
* execute : execute method of the task
*
*/
Task * TaskConstruction( char * name, void ( * execute)()){
    task = (Task * )malloc( sizeof (strlen(name)) + sizeof (execute));
    task -> taskName = name;
    task -> execute = execute;
    task -> _this = task;

     return (Task * )task;//返回一个自身的指针，通过内部的_this指针，两者即可实现封装
}

/*
* Destruction of task, not used current time.
*
*/
void TaskDestruction(){
    task -> taskName = NULL;
    task -> execute = NULL;
    task -> _this = NULL;
    task = NULL;
}

/*
* private method, should register to executor
*
*/
void execute(){
    task -> _this -> execute();//调用_this上的execute()方法
}

执行器的实现一样，稍微复杂一点，构造的时候，将函数指针在内部设置好，当外部调用时动态的执行需要执行的函数，这句话可能有些绕口，这么看：在构造Executor的时候，executor->begin = begin; 这条语句是将下面void begin()的实现注册到结构体中，但是要执行什么还是不确切的，当setTask以后，回调函数的地址已经明确：(executor->_this->task = task;)，此时调用begin()即可正确的调用到注册的Task上。

#include < stdlib.h >
#include " IExecutor.h "

Executor * executor = NULL;

Executor * ExecutorConstruction(){
    executor = (Executor * )malloc( sizeof (Executor));
    executor -> begin = begin;
    executor -> cancel = cancel;
    executor -> setTask = setTask;

    executor -> _this = executor;

     return (Executor * )executor;
}

void ExecutorDestruction(){
    executor -> begin = NULL;
    executor -> cancel = NULL;
    executor -> setTask = NULL;
    executor = NULL;
}

char * setTask(Task * task){
    executor -> _this -> task = task;
}

void begin(){
    printf( " task : [%s] is ready to run\n " ,executor -> _this -> task -> taskName);
    executor -> _this -> task -> execute();
}

void cancel(){//这个函数没有实现，只是做了一个占位符，以后如果有多线程，可以用来停止主动线程。
    printf( " cancel is invoked here\n " );
}

其实，两个实现的代码都不算复杂，如果对C的指针理解的稍好，基本就没什么问题了。

在C中使用OO

为了试验，我们不妨设计两个不同的Task，一个Task是计算两个数的某四则混合运算，另一个仅仅是用来打印一点信息。然后我们可以看到，他们使用完全相同的接口来执行：

#include < stdio.h >

void run(){//计算(a+b)*(a-b)
     float a, b, r;
    a = 1.2 ;
    b = 2.3 ;
    r = 0.0 ;
    printf( " [a = %f, b = %f]\n " , a, b);
    printf( " [(a + b) * (a - b) = %f]\n " ,((a + b) * (a - b)));
}

void run2(){//打印一句话，事实上，这些函数可以做任何事，比如I/O,网络，图片处理，音乐播放等等。
    printf( " another type of execute, " );
    printf( " just print out some information\n " );
}

然后，在Main中奖他们注册给Task，代码如下所示：

#include < stdio.h >
#include < stdlib.h >

#include " ITask.h "
#include " IExecutor.h "

extern void run();
extern void run2();

int main( int argc, char ** argv) {
//代码的风格上，应该可以看出和OO的风格及其类似。
    Task * t1 = TaskConstruction( " Task1 " , run);//new Task("Task 1", run);
    Executor * exe = ExecutorConstruction();// new Executor();
    exe -> setTask(t1);
    exe -> begin();
    exe -> cancel();
　
    Task * t2 = TaskConstruction( " Task2 " , run2);
    exe -> setTask(t2);
    exe -> begin();
    exe -> cancel();

     return (EXIT_SUCCESS);
}

程序的输出结果上文中已经可以看到了，这里就不贴了。

当然，本文的主要目的不是想说什么“C也可以实现面向对象”之类的幼稚观点，只要谁没有严重的自虐倾向，相信不会有谁真的会用C来做OO的开发。只是想表达一下，指针在C中的重要性和指针的一点高级用法。其实现在的OO语言，基本还是以面向过程的表达式来表达面向对象而已。并没有什么神奇之处，OO主要是思想上的抽象，可以说是语言无关的(language independent)。