C语言实现oop特性

#封装

在C语言中，可以用结构+函数指针来模拟类的实现，而用这种结构定义的变量就是对象。
封装的主要含义是隐藏内部的行为和信息，使用者只用看到对外提供的接口和公开的信息。有两种方法实现封装
面向对象的最基本的出发点是“将数据以及处理数据的方法封装在一起”，至于继承、派生、多态之类的则是后面扩展的东西。在C语言中，如果用结构体来保存数据，并将处理这些数据的函数与结构体的定义封装在同一个.c文件中，则该.c文件就可以视作一个类。如果将指向具体函数的函数指针与结构体的其他成员封装在同一个结构体中，则该“对象”的使用甚至与C++相差无几了。

###例子1：
头文件

#ifndef _TEST_H
#define _TEST_H

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

//相当于public的成员
typedef struct Employee
{
    struct Employee_P *This;     //This指针也得放到类里面
    void (*Print)(const struct Employee*); //包含函数指针，用来访问这个函数
}Employee;

extern Employee Employeenew(char *name,int salay);//构造函数
extern  int EmployeeFree(Employee x);//析构函数

#endif

C文件

#include "test.h"

//这个结构体是私有的，相当于private成员，不允许创建对象
typedef struct Employee_P
{
    char name[20];
    int salay;
}Employee_P;

void test_Print(const struct Employee *This)
{
    Employee_P *it = This->This;
    printf("My Name is %s\n",it->name);
    printf("My Salay are %d\n",it->salay);
}

/*构造函数*/
Employee Employeenew(char *name,int salay)
{
    Employee ret;
    Employee_P *p =(Employee_P *)malloc(sizeof(Employee_P));

    strcpy(p->name,name);
    p->salay = salay;

    ret.This =p;        //初始化This指针
    ret.Print =test_Print; //这里初始化函数指针,让它指向Print这个函数
    return ret;
}

/*析构函数*/
int EmployeeFree(Employee x)
{
    free(x.This);
    return 1;
}

主函数调用

int main()
{
    Employee a=Employeenew("Li Hua",1000);//实例化一个对象
    Employee b=Employeenew("Xiao Meng",10000);//实例化一个对象
    a.Print(&a);
    b.Print(&b);
    EmployeeFree(a);//释放一个对象
    EmployeeFree(b);
}

###例子2

这里写代码片

#继承