谈面向对象思想在C语言的运用

Posted 嵌入式ARM

tags:

篇首语:本文由小常识网(cha138.com)小编为大家整理,主要介绍了谈面向对象思想在C语言的运用相关的知识,希望对你有一定的参考价值。

目录

前言1、继承2、封装伪构造函数3、多态

前言

我们都知道C语言是一门过程性语言,所谓过程性就是在解决问题时,将问题按步骤分解。

例如,做菜的时候,先点火,再倒油,接着下菜翻炒,最后加盐和酱油。但有时候借鉴面向对象的思想来组织代码,逻辑层次会更加清晰。

C和C++的最大区别便是,C++有类,C没有类的概念。单单这一个类使得C缺失很多的东西。好在C有结构体,勉强可以当0.1个类来使用。

众所周知,类有三大特性:封装、继承、多态。我们来看看C语言如何借鉴类的三大特性来更好的组织代码。

1、继承

C语言没有严格意义上的继承,可以借助结构体嵌套实现类似于继承的形式,但始终不尽人意。

struct parent
{

    int a;
};
struct son
{

    struct parent p;//儿子继承父亲
    int b;
};

C++的类可以实现成员的访问控制,例如将变量b声明成private,那么外部就无法访问。但C的结构体做不到。

在C++里头,父亲的私有成员,儿子是无法访问的。结构体嵌套也做不到。因为结构体根本就没有访问控制的概念。

对于C++而言,访问控制实质上是在编译层做的,我们仍旧可以通过指针来间接访问。

例如:

class Base{
public:
   int a;
private:
   int b;
};

尽管b被声明成私有,但我们仍旧有办法访问它(借助指针绕过语法检查):

Base t;
int *p = &t.a;
cout << p[1] << endl;

2、封装

封装就是把数据和方法打包到一个类里面。C++的实现大致如下:

class 类名
{

public:
    公有方法1
    公有方法2
    ……
    公有数据1
    ……
private:
    私有方法1
    私有方法2
    ……
    私有数据1
    ……
};

这样做的好处是显而易见的。一个类实现了一个小模块,使得代码结构比较清晰。对外接口和数据定义成public,允许调用者直接访问。内部接口和数据定义成private,外部不可见。

在 QT 中,为了更好的隐藏一个类的具体实现,一般是一个公开头文件、一个私有头文件,私有头文件中定义实现的内部细节,公开头文件中定义开放给客户程序员的接口和公共数据。看看QObject (qobject.h),对应有一QObjectPrivate(qobject_p.h ) ,其他的也类似。

QObject{
public:
    xxx
    xxx
private:
    QObjectPrivate * priv;
};

我们可以借助C语言的指针和结构体来实现方法和数据的封装。基本框架如下:

struct 结构体名{
    数据1
    数据2;
    ……
    方法1:
    方法2;
    ……
}

在结构体里定义成员变量很容易,直接int a;
在结构体里定义成员函数要使用函数指针,比如:

int (*func)(void *)

所以,我们把上面的框架具体化就是:

struct manager{
    int data1;
    int data2;
    int (*operation1)(struct manager*);
    int (*operation2)(struct manager*);
};

在定义结构体之后,函数指针并没有赋值,一般我们会定义一个结构体初始化函数来初始化结构体成员,这有点类似于类的构造函数,但类的构造函数在创建对象时自动调用,而我们这个结构体初始化函数只能自己手动调用了。

同样的,对标C++的析构函数,我们在C语言里头有一个去初始化的函数来完成模块的去初始化,这种思想不就是一样的吗?

static int operation1(struct manager *manager_ptr)
{
    ……
}
static int operation2(struct manager *manager_ptr)
{
    ……
}

伪构造函数

注意,我们把两个operation函数定义成了static,这样子文件之外的函数就不能调用它,只能通过manager结构体来调用。是不是感觉有点封装的意味。

void init_manager(struct manager* manager_ptr)
{
    manager_ptr->operation1 = operation1;
    manager_ptr->operation2 = operation2;
    manager_ptr->data1 = 0;
    manager_ptr->data2 = 0;
}

去初始化函数我就不写了。

如果operation函数在外面的文件定义,则可以作为init_manager函数的参数传入,这种场景也非常常见。我实现了模块A,该模块的operation1函数处理数据并输出一些结果。但是我并不知道使用该模块的人想要什么格式的结果,比如有一些人想要json格式的结果,有些人想要xml格式的结果。我不能帮他们一一实现一个方法,我干脆叫你们统一按照我指定的函数模板,实现一个处理函数,完了你们调用结构体初始化函数注册下,我会在operation1函数处理完数据后,调用你们的处理函数,给你们一个满意的结果。

为了达到上面的目的,简单修改下,我们把函数operation2定义成一种类型,

typedef int  (*FUN_CBK)(struct manager *manager_ptr);

结构体定义稍作修改:

struct manager{
    int data1;
    int data2;
    int (*operation1)(struct manager*);
    FUN_CBK call_back;
};

结构体初始化函数也要做相应的修改,增加了一个函数指针形参:

void init_manager(struct manager* manager_ptr, \
FUN_CBK fun)
{
    manager_ptr->operation1 = operation1;
    manager_ptr->call_back = fun;//用外部传入的回调函数进行初始化
    manager_ptr->data1 = 0;
    manager_ptr->data2 = 0;
}

通过上面的操作,我们用结构体和函数指针完成了模块化封装。

我看了网上的博客,有些人为了特意模仿类,还用以下方式实现了类似于类的构造函数:

struct manager *manager_create(int m, int n)
{
    struct manager *m = (struct manager *)\
    malloc(sizeof(struct manager *));
    m->data1 = m;
    m->data2 = n;
    m->operation1 = operation1;
    m->operation2 = operation2;
}

以及类似于类的析构函数:

void manager_delete(struct manager *m_ptr)
{
    free(m_ptr);
    m_ptr = NULL;
}

使用示例:

struct manager *m_ptr = manager_create (1,2);
manager_delete(m_ptr);

个人不是很喜欢这种做法,万一忘记调用manager_delete还有内存泄露的风险。

结构体归根到底还是结构体,不能实现成员对外不可见。而C++中将成员声明成private之后,外部就无法访问了。C语言里想这么做,只能将该成员移出结构体,定义为static形式。因为C不支持在结构体内部定义static变量(不信,你可以自己去试下)。

3、多态

多态在上面的例子也有体现。C语言实现的多态并非是严格意义上的多态,但是这种思想的应用很广泛,我们姑且叫它多态吧。你不解C++的多态也没关系,丝毫不影响你理解下文。

linux的VFS便借鉴了这种思想。VFS(Virtual File System)是内核提供的文件系统抽象层,其提供了文件系统的操作接口,可以隐藏底层不同文件系统的实现。

一个文件系统无非就是实现对文件、目录的管理。针对文件VFS定义了统一的结构体:

struct file {
    union {
        struct llist_nodefu_llist;
        struct rcu_head fu_rcuhead;
    } f_u;
    struct pathf_path;
    struct inode*f_inode;/* cached value */
    const struct file_operations*f_op;
    ……
}; 

strcut file代表一个文件,每种文件系统(比如ext3,vfat)实现读写等操作的方式都不一样,所以将这些方法封装成函数指针,统一定义在结构体struct file_operations内。

struct file_operations {
    struct module *owner;
    loff_t (*llseek) (struct file *, loff_tint);
    ssize_t (*read) (struct file *, char __user *, size_tloff_t *);
    ssize_t (*write) (struct file *, const char __user *, size_tloff_t *);
    ……
};

每个文件系统各自完成自己的实现。


再写一个实际的例子。
定义一个人的标准接口和数据如下:

strcut man{
    int head;
    int body;
    ……
    void (*say_hello)(void);//见面问候的方式
};

中国人见面时,说你好:

void china_say_hello(void)
{
    printf(“你好”);
}

英国人见面时,说hello:

void english_say_hello(void)
{
    printf(“hello”);
}

现在来初始化它们各自的问候方式:

struct man china{
    .say_hello = china_say_hello;
}
struct man english{
    .say_hello = English_say_hello;
}

英国人和中国人对外呈现都是struct man,其见面问候的接口都是man.say_hello,但其底层实现却可以不一样。

并且我们可以在程序运行时,随意的更改中国人的问候方式。比如婴儿时期,只会“哇哇”叫,长大了才会说“你好”,我们可以改变成员say_hello的值,让其在不同时期指向不同的函数,从而达到运行时多态的目的。


-END-





推荐阅读



【01】
【02】
【03】
【04】
【05】


免责声明:整理文章为传播相关技术,版权归原作者所有,如有侵权,请联系删除

以上是关于谈面向对象思想在C语言的运用的主要内容,如果未能解决你的问题,请参考以下文章

Delphi指针运用理解

谈一谈原生JS中的面向对象思想

再谈编程范式—程序语言背后的思想

面向对象思想实例

浅谈面向对象

java 第六章 面向对象基础