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

最新推荐文章于 2024-08-31 06:09:16 发布
最新推荐文章于 2024-08-31 06:09:16 发布
阅读量634 收藏 16
点赞数 15
分类专栏： C语言系列课程 文章标签： c语言 开发语言 c++ 后端 算法 面向对象 面向过程
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_62599305/article/details/140748687
版权

文章目录

前言

在 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 语言编程中写出更清晰、更模块化的代码，提升程序的可维护性和扩展性。希望本文的介绍能为读者提供一些有用的启发和思路。

人才程序员
关注
  • 15
    点赞
  • 踩
  • 16
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
c语言进阶的编程技巧200例+go语言某培训机构学习笔记
11-11
首先，对于C语言进阶的编程技巧，这些技巧通常涵盖内存管理、指针操作、预处理器宏、函数指针、结构体与联合体、位运算、错误处理等方面。例如，学习如何高效地使用指针可以极大地提升程序的运行效率，理解内存分配...
C语言进阶源码---基于graphics实现图书管理系统
01-04
《C语言进阶源码——基于graphics实现图书管理系统》 图书管理系统是计算机科学中的一个典型应用，它展示了如何使用编程语言来实现数据管理和用户交互。在这个项目中，我们使用了C语言，一种基础且强大的编程语言，...
C语言的结构体可以实现类的基本功能
qq_42831621的博客
08-11 606
核心思想：在结构体中加入方法指针。 #include <stdio.h> #include <string.h> struct Student; typedef struct StudentVtbl { char* (*GetName)(struct Student* This); void(*SetName)(struct Student* This, char*); }StudentVtbl; typedef struct Student {
c语言用结构体实现面向对象,C语言用结构体和指针实现面向对象编程
weixin_30356285的博客
05-25 191
结构体和指针，C语言的灵魂。面向对象我就不班门弄斧解释了。首先，一个结构体：struct Person{char* name;int age;int height;int weight;}那么“造人”吧：struct Person* Create_person(const char* name,int age,int height,int weight){struct Person* who = ...
C语言结构体中的函数指针与函数
成长的企鹅
08-29 879
1、函数指针 一般的函数指针可以这么定义: int(*func)(int,int); 表示一个指向含有两个int参数并且返回值是int形式的任何一个函数指针. 假如存在这样的一个函数： int add2(int x,int y) { return x+y; } 那么在实际使用指针func时可以这样实现:func=&amp;add2; //指针赋值,或者func...
c语言结构体实现类似c++类构造函数
xiaoxiao123_1的博客
06-06 4316
这两天看了一下函数指针，就实现了一下用结构体实现类似于类定义的功能。 #include typedef struct demo {  int i;  int j;  int (*geti)(struct demo *it);  int (*getj)(struct demo *it);  void (*set)(struct demo *it, int i, int j)
C语言进阶教程（使用C语言编写出面向对象的代码）
m0_49476241的博客
07-29 813
本篇文章我们开始学习C语言进阶教程，我们来使用C语言写出面向对象的代码，写出这种代码主要为了方便代码进行工程管理和维护。首先，定义一个表示LED灯的结构体和相关的操作函数。} Led;// 具体的硬件操作，假设使用GPIO来控制LED// 伪代码// 具体的硬件操作，假设使用GPIO来控制LED// 伪代码// 具体的硬件操作，假设使用GPIO来控制LED// 伪代码return -1;// 错误值。
C语言结构体（struct）常见使用方法
热门推荐
huqinwei的专栏
04-14 65万+
注意：盗版是不会得到修正和更新的！ 今天复习一下struct，顺便挖掘一下以前没注意的小细节： 基本定义：结构体，通俗讲就像是打包封装，把一些有共同特征（比如同属于某一类事物的属性，往往是某种业务相关属性的聚合）的变量封装在内部，通过一定方法访问修改内部变量。 （因为C++和C有共通之处，但是在结构体上的某些机制又有所不同，所以后边提了一下，不喜欢可以略过） 结构体定义： ...
【C语言进阶】C语言实现类似C++的函数重载
m0_62599305的博客
07-28 316
在C++中，函数重载（Function Overloading）是一种常见且强大的特性，它允许多个同名函数在参数类型或参数数量不同的情况下共存，从而提供更灵活和简洁的代码接口。然而，C语言并不直接支持函数重载，因为C语言在设计之初并未包含面向对象编程的特性。不过，通过一些技巧和设计模式，我们可以在C语言中模拟出类似于C++函数重载的效果。本文将探讨几种在C语言中实现函数重载的方法。在C语言中，没有直接的函数重载功能（即相同函数名但不同参数列表的函数）。然而，可以通过一些技巧来模拟函数重载。
C语言--面向对象编程之封装
weixin_46185705的博客
03-14 4133
文章目录前言一、面向对象基本概念什么是对象？对象与类面向对象的编程方式二、C语言实现面向对象面向对象的三大特征面向对象之封装简介代码实现2.读入数据总结 前言 面向对象是一种思维方式，基本上用什么语言都是可以实现的。C语言的编程方式一般是面向过程的，但是也是可以实现面向对象的。对象是什么？什么又是面向对象？面向对象的三大特性又怎么实现，且听我细细道来。 一、面向对象基本概念 什么是对象？ 此对象非彼对象，虽然有时候此对象又可以是你脑袋中的对象，那让我们从我们误解的对象开始了解吧，虽然我没有，但是用一下自
c语言进阶_C语言进阶_源码
10-02
在C++部分，你将接触到类和对象的概念，这是面向对象编程的基础。类的封装、继承、多态等特性将被详细介绍，同时也会涵盖模板和异常处理等高级主题。C++的STL（标准模板库）如容器、算法和迭代器等也将有所涉猎，...
C语言进阶之C语言简介
02-15
4. **面向过程**：C语言是面向过程的，强调通过函数来组织程序，而不是面向对象的语言那样通过类和对象。 5. **丰富的库支持**：C语言提供了大量的标准库函数，如数学运算、字符串处理、输入输出等，方便开发者使用...
c语言定义学员结构体【进阶用法】结构体可以包含函数，具有类的功能。
介绍结构体在C语言中的基本概念 ## 1.1 结构体的定义与声明 在C语言中，结构体是一种用户自定义的数据类型，可以包含多个不同类型的成员变量。通过定义结构体，我们可以将多个相关的数据组合在一起，方便进行管理...
C语言 | Leetcode C语言题解之第386题字典序排数
最新发布
m0_59237910的博客
08-31 504
C语言 | Leetcode C语言题解之第386题字典序排数
C语言 | Leetcode C语言题解之第385题迷你语法分析器
m0_59237910的博客
08-31 516
C语言 | Leetcode C语言题解之第385题迷你语法分析器
C primer plus 7.2.1 介绍getchar（）和putchar（）
xnglan的博客
08-27 338
getchar（）函数不带任何参数，他从输入队列中返回下一个字符。如：下面的语句读取下一个字符输入，并把该字符赋值给变量ch。下面通过一个程序来说明它是如何工作的：”如果字符是空白，原样打印;否则，打印原字符在ASCII序列的下一个字符“由于这些函数只处理字符，所以他们比更通用的scanf（）和printf（）函数。该程序再次演示了字符实际上是以整数储存的，所以能putcha（ch + 1）putchar（）函数打印它的参数。并且getchar（）和putchar（）getchar（）和putchar（）
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

人才程序员

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值