面向对象编程

C语言面向对象编程

记得还在我们大学C++第一门课的时候，老师就告诉我们说，C++是一门面向对象的语言。C++有三个最重要的特点，即继承、封装、多态。等到后来随着编码的增多和工作经验的积累，我也慢慢明白了面向对象的含义。可是，等我工作以后，使用的编程语言更多的是C语言，这时候我又想能不能把C语言变成面向对象的语言呢？等到后来通过思考和实践，我发现其实C语言也是可以面向对象的，也是可以应用设计模式的，关键就在于如何实现面向对象语言的三个重要属性。

C++的结构体可以包含函数，但是C语言的结构体不可以包含函数，只有成员变量，可以用函数指针映射一个函数，实现结构体的封装。

继承

typedef struct _parent  
{  
     int data_parent;  
 }Parent;  

typedef struct _Child  
{  
    struct _parent parent;  
    int data_child;
}Child;

在设计C语言继承性的时候，我们需要做的就是把基础数据放在继承的结构的首位置即可。这样，不管是数据的访问、数据的强转、数据的访问都不会有什么问题。

封装

struct _Data;  

typedef  void (*process)(struct _Data* pData);  

typedef struct _Data  
{  
    int value;  
    process pProcess;
}Data;

封装性的意义在于，函数和数据是绑在一起的，数据和数据是绑在一起的。这样，我们就可以通过简单的一个结构指针访问到所有的数据，遍历所有的函数。封装性，这是类拥有的属性，当然也是数据结构体拥有的属性。

多态

typedef struct _Play  
{  
    void* pData;  
    void (*start_play)(struct _Play* pPlay);  
}Play;

多态，就是说用同一的接口代码处理不同的数据。比如说，这里的Play结构就是一个通用的数据结构，我们也不清楚pData是什么数据，start_play是什么处理函数？但是，我们处理的时候只要调用pPlay->start_play(pPlay)就可以了。剩下来的事情我们不需要管，因为不同的接口会有不同的函数去处理，我们只要学会调用就可以了。

C++中的面向对象编程

class cmd
{
public:
    char *p;

public:
    void run()
    {
        system(p);
    }

    void print()
    {
        std::cout << p << std::endl;
    }
};

class newcmd :public cmd
{
public:
    int getlength()
    {
        return strlen(this->p);
    }
};

void main()
{
    newcmd cmd1;
    cmd1.p = "calc";
    cmd1.run();
    cmd1.print();
    std::cout << cmd1.getlength() << std::endl;

    system("pause");
}

C语言中的面向对象编程

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

struct cmd  
{  
    char *p;  
    void (*prun)(struct cmd *pcmd); // 用函数指针表示一个函数
    void (*pprint)(struct cmd *pcmd);
};  

typedef  struct cmd  CMD;  

void run(CMD *pcmd )  
{  
    system(pcmd->p);  
}  

void print(CMD *pcmd)  
{  
    printf("%s", pcmd->p);  
}  

struct newcmd  
{  
    struct cmd cmd1;  // 实现继承
    int(*plength)(struct newcmd *pnewcmd); // 增加新的功能
};  

int getlength(struct newcmd *pnewcmd)  
{  
    return strlen(pnewcmd->cmd1.p);//返回长度  
}  

void main1()  
{  
    CMD cmd1 = { "notepad", run, print };  
    cmd1.pprint(&cmd1);  
    cmd1.prun(&cmd1);  

    system("pause");  
}  

void main()  
{  
    struct newcmd newcmd1;  
    newcmd1.cmd1.p = "notepad";  
    newcmd1.cmd1.pprint = print;  
    newcmd1.cmd1.prun = run;  
    newcmd1.plength = getlength;//初始化  

    newcmd1.cmd1.pprint(&newcmd1.cmd1);  
    newcmd1.cmd1.prun(&newcmd1.cmd1);  
    printf("%d",newcmd1.plength(&newcmd1));  
    system("pause");  
}

C++中的多态

#include<iostream>
#include<stdlib.h>

class Person
{
public:
    virtual void gettooth()
    {
        printf("牙齿");
    }
};

class Woman :public Person
{
public:
    void gettooth()
    {
        printf("男人的虎牙\n");
        system("notepad");
    }
};

class Man :public Person
{
public:
    void gettooth()
    {
        printf("女人的白牙\n");
        system("calc");
    }
};

int main()
{
    Woman  woman;
    woman.gettooth();
    woman.Person::gettooth();

    Man   man;
    man.gettooth();
    man.Person::gettooth();

    return 0; 
}

C语言中的多态

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

struct Person  
{  
    void(*fun)(struct Person *p);  
};  

struct Man  
{  
    struct Person person;  
    void(*fun)(struct Man *pm);  
};  

void work(struct Man *pm)  
{  
    printf("工作\n");  
}  

struct Woman 
{  
    struct Person person;
    void(*fun)(struct Woman *pw);  
};  

void shopping(struct Woman *pw)  
{  
    printf("购物\n");  
}  

void eat(struct Person *person)  
{  
    printf("吃饭\n");  
}  

int main()  
{  
    struct Man  man;  
    man.person.fun = eat;  
    man.person.fun(&man.person);  

    man.fun = work;  
    man.fun(&man);  

    struct Woman   woman;  
    woman.person.fun = eat;  
    woman.person.fun(&woman.person);  
    woman.fun = shopping;  
    woman.fun(&woman);  

    return 0;  
}