前言
在 C 语言中,虽然没有直接支持面向对象编程的特性,但我们可以通过一些技巧和方法来实现类似的面向对象编程思想。其中,结构体是实现这一目标的一个重要工具。通过将数据和操作这些数据的函数封装在一起,我们可以模拟类和对象的行为。本篇文章将介绍如何利用结构体来实现面向对象编程的基本思想。
对象内部函数定义方法
1. 使用函数指针把函数存储到对象内部
#include <stdio.h>
#include <stdlib.h>
struct Animal
{
int age;
char *name;
void (*Introduce)(struct Animal* self);
void (*Eat)(struct Animal* self, char* food);
void (*Run)(struct Animal* self);
};
void _Introduce(struct Animal* self)
{
printf("我是:%s\n", self->name);
self->Eat(self,"草");
self->Run(self);
}
void _Eat(struct Animal* self, char* food)
{
printf("我能吃:%s\n", food);
}
void _Run(struct Animal* self)
{
printf("我能跑\n");
}
struct Animal* CreateAnimal(char *name)
{
struct Animal* ret = (struct Animal*)malloc(sizeof(struct Animal));
ret->name = name;
ret->Introduce = _Introduce;
ret->Eat = _Eat;
ret->Run = _Run;
return ret;
}
int main()
{
struct Animal* ani = CreateAnimal("无名的动物");
ani->Introduce(ani);
return 0;
}
代码介绍
这段代码实现了一个简单的面向对象风格的程序,定义了一个 Animal
结构体和相关的函数。通过使用函数指针,将方法与结构体绑定,实现类似于面向对象编程的效果。下面是对代码的详细解释:
-
结构体定义:
struct Animal { int age; char *name; void (*Introduce)(struct Animal* self); void (*Eat)(struct Animal* self, char* food); void (*Run)(struct Animal* self); };
这个结构体
Animal
包含三个字段:age
、name
和三个函数指针Introduce
、Eat
、Run
。这些函数指针指向的是操作Animal
的方法。 -
方法实现:
void _Introduce(struct Animal* self) { printf("我是:%s\n", self->name); self->Eat(self, "草"); self->Run(self); } void _Eat(struct Animal* self, char* food) { printf("我能吃:%s\n", food); } void _Run(struct Animal* self) { printf("我能跑\n"); }
这些方法分别实现了
Introduce
、Eat
和Run
的功能。其中_Introduce
方法调用了Eat
和Run
方法。 -
对象创建函数:
struct Animal* CreateAnimal(char *name) { struct Animal* ret = (struct Animal*)malloc(sizeof(struct Animal)); ret->name = name; ret->Introduce = _Introduce; ret->Eat = _Eat; ret->Run = _Run; return ret; }
这个函数分配内存并初始化一个
Animal
对象,同时将方法指针指向具体的实现。 -
主函数:
int main() { struct Animal* ani = CreateAnimal("无名的动物"); ani->Introduce(ani); return 0; }
在主函数中,创建了一个
Animal
对象,并调用了Introduce
方法。
方法写在结构体外部
将方法从结构体中分离出来,可以使代码结构更清晰。下面是重写后的代码:
#include <stdio.h>
#include <stdlib.h>
struct Animal {
int age;
char *name;
};
// 方法声明
void Introduce(struct Animal* self);
void Eat(struct Animal* self, char* food);
void Run(struct Animal* self);
// 方法实现
void Introduce(struct Animal* self) {
printf("我是:%s\n", self->name);
Eat(self, "草");
Run(self);
}
void Eat(struct Animal* self, char* food) {
printf("我能吃:%s\n", food);
}
void Run(struct Animal* self) {
printf("我能跑\n");
}
// 对象创建函数
struct Animal* CreateAnimal(char *name) {
struct Animal* ret = (struct Animal*)malloc(sizeof(struct Animal));
ret->name = name;
return ret;
}
int main() {
struct Animal* ani = CreateAnimal("无名的动物");
Introduce(ani);
// 释放内存
free(ani);
return 0;
}
在这个版本中:
- 方法
Introduce
、Eat
和Run
被移到结构体外部,成为独立的函数。 - 结构体
Animal
只包含数据字段age
和name
。 - 在主函数中,直接调用这些独立的函数来操作
Animal
对象。
结构体的继承
我们可以使用子类里面存储父类的方法来实现。这样你的函数也需要再复制一遍
#include <stdio.h>
#include <stdlib.h>
struct Animal
{
int age;
char *name;
void (*Introduce)(struct Animal* self);
void (*Eat)(struct Animal* self, char* food);
void (*Run)(struct Animal* self);
};
struct Person
{
struct Animal* obj;
int high;
int money;
void (*work)(struct Person* self);
void (*Introduce)(struct Animal* self);
void (*Eat)(struct Animal* self, char* food);
void (*Run)(struct Animal* self);
};
void _Introduce(struct Animal* self)
{
printf("我是:%s\n", self->name);
self->Eat(self,"草");
self->Run(self);
}
void _Eat(struct Animal* self, char* food)
{
printf("我能吃:%s\n", food);
}
void _Run(struct Animal* self)
{
printf("我能跑\n");
}
void _work(struct Person* self)
{
printf("我是苦逼的程序员,我%dcm,我有%d块钱\n", self->high, self->money);
}
struct Animal* CreateAnimal(char *name)
{
struct Animal* ret = (struct Animal*)malloc(sizeof(struct Animal));
ret->name = name;
ret->Introduce = _Introduce;
ret->Eat = _Eat;
ret->Run = _Run;
return ret;
}
struct Person* CreatePerson(char* name,int high,int money)
{
struct Person* ret = (struct Person*)malloc(sizeof(struct Person));
ret->obj = CreateAnimal(name);
ret->high = high;
ret->money = money;
ret->Introduce = ret->obj->Introduce;
ret->Eat = ret->obj->Eat;
ret->Run = ret->obj->Run;
ret->work = _work;
return ret;
}
int main()
{
struct Person* ani = CreatePerson("张三",180,10000);
ani->Introduce(ani->obj);
ani->work(ani);
return 0;
}
重写父类函数
我们只需要在创建子类时,把父类的对应的函数指针地址改了就行
#include <stdio.h>
#include <stdlib.h>
struct Animal
{
int age;
char *name;
void (*Introduce)(struct Animal* self);
void (*Eat)(struct Animal* self, char* food);
void (*Run)(struct Animal* self);
};
struct Person
{
struct Animal* obj;
int high;
int money;
void (*work)(struct Person* self);
void (*Introduce)(struct Animal* self);
void (*Eat)(struct Animal* self, char* food);
void (*Run)(struct Animal* self);
};
void _Introduce(struct Animal* self)
{
printf("我是:%s\n", self->name);
self->Eat(self,"草");
self->Run(self);
}
void _Eat(struct Animal* self, char* food)
{
printf("我能吃:%s\n", food);
}
void _Run(struct Animal* self)
{
printf("我能跑\n");
}
void _work(struct Person* self)
{
printf("我是苦逼的程序员,我%dcm,我有%d块钱\n", self->high, self->money);
}
void _IntroducePerson(struct Person* self)
{
}
struct Animal* CreateAnimal(char *name)
{
struct Animal* ret = (struct Animal*)malloc(sizeof(struct Animal));
ret->name = name;
ret->Introduce = _Introduce;
ret->Eat = _Eat;
ret->Run = _Run;
return ret;
}
struct Person* CreatePerson(char* name,int high,int money)
{
struct Person* ret = (struct Person*)malloc(sizeof(struct Person));
ret->obj = CreateAnimal(name);
ret->high = high;
ret->money = money;
//ret->Introduce = ret->obj->Introduce;
ret->Introduce = _IntroducePerson;//重写
ret->Eat = ret->obj->Eat;
ret->Run = ret->obj->Run;
ret->work = _work;
return ret;
}
int main()
{
struct Person* ani = CreatePerson("张三",180,10000);
ani->Introduce(ani->obj);
ani->work(ani);
return 0;
}
实现多态
#include <stdio.h>
#include <stdlib.h>
struct Animal
{
int age;
char* name;
void (*Introduce)(struct Animal* self);
void (*Eat)(struct Animal* self, char* food);
void (*Run)(struct Animal* self);
};
struct Person
{
struct Animal* obj;
int high;
int money;
void (*work)(struct Person* self);
void (*Introduce)(struct Animal* self);
void (*Eat)(struct Animal* self, char* food);
void (*Run)(struct Animal* self);
};
void _Introduce(struct Animal* self)
{
printf("我是: %s\n", self->name);
self->Eat(self, "草");
self->Run(self);
}
void _Eat(struct Animal* self, char* food)
{
printf("我能吃: %s\n", food);
}
void _Run(struct Animal* self)
{
printf("我能跑\n");
}
void _work(struct Person* self)
{
printf("我是苦逼的程序员,我 %d cm,我有 %d 块钱\n", self->high, self->money);
}
void _IntroducePerson(struct Animal* self)
{
struct Person* person = (struct Person*)self;
printf("我是人类: %s\n", person->obj->name);
person->obj->Introduce(person->obj); // 调用Animal的Introduce
printf("我 %d cm,我有 %d 块钱\n", person->high, person->money);
}
struct Animal* CreateAnimal(char* name)
{
struct Animal* ret = (struct Animal*)malloc(sizeof(struct Animal));
ret->name = name;
ret->Introduce = _Introduce;
ret->Eat = _Eat;
ret->Run = _Run;
return ret;
}
struct Person* CreatePerson(char* name, int high, int money)
{
struct Person* ret = (struct Person*)malloc(sizeof(struct Person));
ret->obj = CreateAnimal(name);
ret->high = high;
ret->money = money;
ret->Introduce = _IntroducePerson; // 重写
ret->Eat = ret->obj->Eat;
ret->Run = ret->obj->Run;
ret->work = _work;
return ret;
}
int main()
{
struct Person* ani = CreatePerson("张三", 180, 10000);
ani->Introduce((struct Animal*)ani); // 使用Person的Introduce
ani->work(ani);
// 释放内存
free(ani->obj);
free(ani);
return 0;
}
实现析构函数
在 C 语言中,并不像在 C++ 中那样有构造函数和析构函数的概念。为了实现类似析构函数的功能,你需要自己定义一个释放资源的函数,然后在适当的时候调用它,例如在对象不再需要使用的时候。
为了自动调用析构函数,通常你需要一种机制来跟踪对象的生命周期。例如,使用智能指针或引用计数来管理对象的分配和释放。然而,C 语言没有内置的智能指针或引用计数功能,需要手动实现这些功能。
下面是一个简单的例子,展示如何实现类似析构函数的功能:
#include <stdio.h>
#include <stdlib.h>
struct Animal
{
int age;
char *name;
void (*Introduce)(struct Animal* self);
void (*Eat)(struct Animal* self, char* food);
void (*Run)(struct Animal* self);
void (*Destroy)(struct Animal* self);
};
struct Person
{
struct Animal* obj;
int high;
int money;
void (*work)(struct Person* self);
void (*Introduce)(struct Animal* self);
void (*Eat)(struct Animal* self, char* food);
void (*Run)(struct Animal* self);
void (*Destroy)(struct Person* self);
};
void _Introduce(struct Animal* self)
{
printf("我是: %s\n", self->name);
self->Eat(self, "草");
self->Run(self);
}
void _Eat(struct Animal* self, char* food)
{
printf("我能吃: %s\n", food);
}
void _Run(struct Animal* self)
{
printf("我能跑\n");
}
void _DestroyAnimal(struct Animal* self)
{
// 这里可以添加更多的清理逻辑
free(self);
}
void _work(struct Person* self)
{
printf("我是苦逼的程序员,我 %d cm,我有 %d 块钱\n", self->high, self->money);
}
void _IntroducePerson(struct Animal* self)
{
struct Person* person = (struct Person*)self;
printf("我是人类: %s\n", person->obj->name);
person->obj->Introduce(person->obj); // 调用Animal的Introduce
printf("我 %d cm,我有 %d 块钱\n", person->high, person->money);
}
void _DestroyPerson(struct Person* self)
{
self->obj->Destroy(self->obj); // 销毁Animal对象
// 这里可以添加更多的清理逻辑
free(self);
}
struct Animal* CreateAnimal(char *name)
{
struct Animal* ret = (struct Animal*)malloc(sizeof(struct Animal));
ret->name = name;
ret->Introduce = _Introduce;
ret->Eat = _Eat;
ret->Run = _Run;
ret->Destroy = _DestroyAnimal;
return ret;
}
struct Person* CreatePerson(char* name, int high, int money)
{
struct Person* ret = (struct Person*)malloc(sizeof(struct Person));
ret->obj = CreateAnimal(name);
ret->high = high;
ret->money = money;
ret->Introduce = _IntroducePerson; // 重写
ret->Eat = ret->obj->Eat;
ret->Run = ret->obj->Run;
ret->work = _work;
ret->Destroy = _DestroyPerson;
return ret;
}
int main()
{
struct Person* ani = CreatePerson("张三", 180, 10000);
ani->Introduce((struct Animal*)ani); // 使用Person的Introduce
ani->work(ani);
// 使用Destroy函数自动释放资源
ani->Destroy(ani);
return 0;
}
在这个例子中,我们为 Animal
和 Person
结构体分别添加了 Destroy
方法,用于释放对象所占用的资源。在 main
函数中,调用 ani->Destroy(ani);
来自动释放资源,而不需要手动调用 free
。这样就实现了类似析构函数的功能。
总结
通过使用结构体,我们可以在 C 语言中实现类似面向对象编程的功能。这种方法虽然没有真正的面向对象语言那么直观和方便,但它依然可以提供较好的代码组织和复用性。理解并掌握这些技巧,可以帮助我们在 C 语言编程中写出更清晰、更模块化的代码,提升程序的可维护性和扩展性。希望本文的介绍能为读者提供一些有用的启发和思路。