【C语言进阶】使用结构体实现面向对象

举报
人才程序员 发表于 2024/07/28 20:25:07 2024/07/28
【摘要】 @TOC 前言在 C 语言中，虽然没有直接支持面向对象编程的特性，但我们可以通过一些技巧和方法来实现类似的面向对象编程思想。其中，结构体是实现这一目标的一个重要工具。通过将数据和操作这些数据的函数封装在一起，我们可以模拟类和对象的行为。本篇文章将介绍如何利用结构体来实现面向对象编程的基本思想。 对象内部函数定义方法 1. 使用函数指针把函数存储到对象内部#include <stdio.h>#...

@TOC

前言

在 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 结构体和相关的函数。通过使用函数指针，将方法与结构体绑定，实现类似于面向对象编程的效果。下面是对代码的详细解释：

  1. 结构体定义：

    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 的方法。

  2. 方法实现：

    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 方法。

  3. 对象创建函数：

    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 对象，同时将方法指针指向具体的实现。

  4. 主函数：

    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;
}

在这个版本中：

  1. 方法 Introduce、Eat 和 Run 被移到结构体外部，成为独立的函数。
  2. 结构体 Animal 只包含数据字段 age 和 name。
  3. 在主函数中，直接调用这些独立的函数来操作 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 语言编程中写出更清晰、更模块化的代码，提升程序的可维护性和扩展性。希望本文的介绍能为读者提供一些有用的启发和思路。

【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱： cloudbbs@huaweicloud.com
面向对象编程
  • 点赞
  • 收藏
  • 关注作者

评论（0）

0/1000
抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认 取消

加入云驻计划，成为创作者

  • 华为云周边好礼
  • 免费体验产品
  • 特殊身份标识
  • 线下官方门票
  • 内部专家零距离
  • 与10000+优质创作者共同成长
立即加入