c语言实现继承和多态

最新推荐文章于 2022-10-18 15:57:14 发布
最新推荐文章于 2022-10-18 15:57:14 发布
阅读量370 收藏
点赞数
文章标签： c语言
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_35523575/article/details/109562655
版权

c语言实现继承和多态

重点：
继承：模仿c++中vtable
多态：交叉组合引用

#pragma once
#define _CRT_SECURE_NO_WARNINGS
#include<stdio.h>
#include<string.h>
#include<stdlib.h>

/*在c中实现继承和多态*/
//Person.h
//typedef struct _Person
//{
//	char* pFirstName;
//	char* pLastName;
//}Person;
/*构造函数声明*/

/*重新定义_Person 实现Person*/
/*实现一个vtable函数表*/
typedef struct _Person Person;/*相当于前向声明*/
typedef struct _Employee Employee;
typedef void (*fptrDisplayInfo)(Person*);
typedef void (*fptrWriteToFile)(Person*, const char*);
typedef void (*fptrDelete)(Person*);
typedef struct _Person
{

	char* pFName;
	char* pLName;
	fptrDisplayInfo Display;
	fptrWriteToFile WriteToFile;
	fptrDelete Delete;
	Employee* pDerivedObj;/*保存派生类对象*/
}Person;



Person* new_Person(const char* const pFirstName, const char* const pLastName);
void delete_Person(Person* const pPersonObj);//destructor
void Person_DisplayInfo(Person* const pPersonObj);
void Person_WriteToFile(Person* const pPersonObj, const char* const pFileName);

Person* new_Person(const char* const pFirstName, const char* const pLastName)
{
	printf("基类构造函数开始\n");
	Person* pObj = NULL;
	pObj = (Person*)malloc(sizeof(Person));
	if (NULL == pObj)
	{
		return NULL;
	}
	pObj->pDerivedObj = pObj;
	pObj->pFName = malloc(sizeof(char)*(strlen(pFirstName) + 1));
	memset(pObj->pFName, 0x00, sizeof(pObj->pFName));
	if (NULL == pObj->pFName)
	{
		return NULL;
	}
	strcpy(pObj->pFName, pFirstName);
	pObj->pLName = malloc(sizeof(char)*(strlen(pLastName) + 1));
	memset(pObj->pLName, 0x00, sizeof(pObj->pLName));
	if (NULL == pObj->pLName)
	{
		return NULL;
	}
	strcpy(pObj->pLName, pLastName);
	pObj->Delete = delete_Person;
	pObj->Display = Person_DisplayInfo;
	pObj->WriteToFile = Person_WriteToFile;
	printf("基类构造函数结束\n");
	return pObj;
}
void delete_Person(Person* const pPersonObj)
{
	printf("基类析构函数开始\n");
	if (pPersonObj->pFName != NULL)
	{
		free(pPersonObj->pFName);
		pPersonObj->pFName = NULL;
	}
	if (pPersonObj->pLName != NULL)
	{
		free(pPersonObj->pLName);
		pPersonObj->pLName = NULL;
	}
	printf("基类析构函数结束\n");
}
void Person_WriteToFile(Person* const pPersonObj, const char* const pFileName)
{
	printf("基类成员函数1开始\n");
	if (NULL == pPersonObj)
	{
		return;
	}
	FILE* fptr = fopen(pFileName, "wt");
	if (NULL == fptr)
	{
		return;
	}
	char buf[BUFSIZ];
	memset(buf, 0x00, sizeof(buf));
	sprintf(buf, "%s %s", pPersonObj->pFName, pPersonObj->pLName);
	fwrite(buf, sizeof(buf), 1, fptr);
	fclose(fptr);
	return;
}
void Person_DisplayInfo(Person* const pPersonObj)
{
	printf("基类成员函数2开始\n");
	if (NULL == pPersonObj)
	{
		return;
	}
	printf("My Name is %s %s\n", pPersonObj->pFName, pPersonObj->pLName);
	return;
}

/*多态的简单例子*/
/*创建Person的时候初始化Employee*/
/*在c中继承可以通过在派生类对象中维护一个基类对象的引用来完成
为了实现虚函数，派生类的函数签名应该和基类的函数指针类似，即派生类函数将以基类对象的一个实例为参数
在基类中维护一个派生类的引用，在函数实现上，可以从派生类的引用访问实际派生类的数据*/
void test01()
{
	/*创建完对象之后，能够访问它的数据成员和函数*/
	Person* pPerson = new_Person("yimao", "666");
	pPerson->Display(pPerson);
	pPerson->WriteToFile(pPerson, "1.txt");
	pPerson->Delete(pPerson);
	pPerson = NULL;

}
typedef struct _Employee
{
	Person* pBaseObj; /*维护基类对象的引用*/
	char* pDepartment;
	char* pCompany;
	int salary;
	/*需要使用基类的接口指向派生类的成员函数使基类对象（多态）灵活调用派生类函数*/
	/*析构：使基类的删除函数指针指向派生类的析构函数，派生类的析构函数清楚派生类的数据和基类的数据和对象
	*/
}Employee;
Person* new_Employee(const char* const pFirstName, const char* const pLastName, const char* const pDepartment, const char* const pCompany, int nSalary);
void delete_Employee(Person* const pPersonObj);
void Employee_DisplayInfo(Person* const pPersonObj);
void Emplyee_WriteToFile(Person* const pPersonObj, const char* const pFileName);
Person* new_Employee(const char* const pFirstName, const char* const pLastName, const char* const pDepartment, const char* const pCompany, int nSalary)
{
	printf("派生类构造函数开始\n");
	Employee* pEmpObj;
	Person* pObj = new_Person(pFirstName, pLastName);
	pEmpObj = malloc(sizeof(Employee));
	memset(pEmpObj, 0x00, sizeof(pEmpObj));
	if (NULL == pEmpObj)
	{
		pObj->Delete(pObj);
		return NULL;
	}
	pObj->pDerivedObj = pEmpObj;
	pEmpObj->pDepartment = malloc(sizeof(char)*strlen(pDepartment)+1);
	memset(pEmpObj->pDepartment, 0x00, sizeof(pEmpObj->pDepartment));
	if (NULL == pEmpObj->pDepartment)
	{
		return NULL;
	}
	strcpy(pEmpObj->pDepartment, pDepartment);
	pEmpObj->pCompany = malloc(sizeof(char)*strlen(pCompany)+1);
	memset(pEmpObj->pCompany, 0x00, sizeof(pEmpObj->pCompany));
	if (NULL == pEmpObj->pCompany)
	{
		return NULL;
	}
	strcpy(pEmpObj->pCompany, pCompany);
	pEmpObj->salary = nSalary;
	pObj->Delete = delete_Employee;
	pObj->Display = Employee_DisplayInfo;
	pObj->WriteToFile = Emplyee_WriteToFile;

	pObj->WriteToFile = Emplyee_WriteToFile;
	printf("派生类构造函数结束\n");
	return pObj;


}
void delete_Employee(Person* const pPersonObj)
{

	printf("派生类析构函数开始\n");
	if (NULL == pPersonObj)
	{
		return;
	}
	//Employee* pTmp = (Employee*)(pPersonObj->pDerivedObj);

	if (pPersonObj->pFName != NULL)
	{
		free(pPersonObj->pFName);
		pPersonObj->pFName = NULL;
	}
	if (pPersonObj->pLName != NULL)
	{
		free(pPersonObj->pLName);
		pPersonObj->pLName = NULL;
	}
	if (pPersonObj->pDerivedObj != NULL)
	{
	
			/*这里隐藏着一个问题：如果先释放pDepartment会报错debug error*/
			if (pPersonObj->pDerivedObj->pDepartment != NULL)
			{
				free(pPersonObj->pDerivedObj->pDepartment);
				pPersonObj->pDerivedObj->pDepartment = NULL;
			}
			if (pPersonObj->pDerivedObj->pCompany != NULL)
			{
				free(pPersonObj->pDerivedObj->pCompany);
				pPersonObj->pDerivedObj->pCompany = NULL;
			}

		free(pPersonObj->pDerivedObj);
		pPersonObj->pDerivedObj = NULL;
	}

	free(pPersonObj);
	printf("派生类析构函数结束\n");

}
void Employee_DisplayInfo(Person* const pPersonObj)
{
	printf("派生类成员函数1\n");
	printf("My Name is %s %s %s %s\n", pPersonObj->pFName, pPersonObj->pLName, pPersonObj->pDerivedObj->pDepartment, pPersonObj->pDerivedObj->pCompany);
}
void Emplyee_WriteToFile(Person* const pPersonObj, const char* const pFileName)
{
	printf("派生类成员函数2");
}
/*使用多态*/
void test02()
{
	Person* PersonObj = new_Person("yimao", "123");
	Person* EmployeeObj = new_Employee("ermao", "123", "HR", "TCS", 40000);
	PersonObj->Display(PersonObj);
	PersonObj->WriteToFile(PersonObj, "1.txt");

	PersonObj->Delete(PersonObj);
	EmployeeObj->WriteToFile(EmployeeObj, "employee.txt");
	EmployeeObj->Display(EmployeeObj);
	EmployeeObj->Delete(EmployeeObj);
}
int main()
{
	test02();


	system("pause");
	return EXIT_SUCCESS;
}

运行结果
在这里插入图片描述以上代码中最后一个释放函数存在问题，待解决！！！

一毛颠
关注
C语言实现继承和多态
程序员黄老师的精品课！
07-13 1785
#include #include #include //-------------  Person  -------------- typedef struct Person {     void* derived_obj;     char* name;     void (*life)(struct Person*);     void (*live)(stru
c语言实现继承与多态
05-03
虽然面向对象的设计并不会在很大程度上依赖于某种语言，但现代著作中提及面向对象的实现一般都认为是C++, Smalltalk, 或者Java。 本文从较底层的视角用面向过程的语言（比如C）对面向对象予以实现，这对于一些想运用面向对象思想但又不想切换到面向对象语言的嵌入式开发者会起一定的指导作用.
C中的继承和多态
weixin_33943347的博客
09-23 234
1、引言 继承和多态是面向对象语言最强大的功能。有了继承和多态，我们可以完成代码重用。在C中有许多技巧可以实现多态。本文的目的就是演示一种简单和容易的技术，在C中应用继承和多态。通过创建一个VTable（virtual table）和在基类和派生类对象之间提供正确的访问，我们能在C中实现继承和多态。VTable能通过维护一张函数表指针表来实现。为了提供基类和派生类对象之间的访问，我们可以在基类中...
C语言实现多态
热门推荐
feiqiangs的专栏
09-23 1万+
综述 多态性是面向对象程序设计的一个重要特征，利用多态性可以设计和实现一个易于扩展的系统。 顾名思义，多态的意思是多种形态，在C++程序设计中，多态指的是：具有不同功能的函数可以用同一个函数名，这样可以用一个函数名调用不同内容的函数。 C++的多态分两种：静态多态性和动态多态性。 1. C++中的函数重载和运算符重载实现的多态性就属于静态多态，在程序编译时系统就能决定调用的是哪个函数，因此
C语言 | 实现继承和多态
张登雨的博客
10-13 290
题目 C语言实现继承和多态 实现要求如下： C 实现一个 struct A 和 stuct B 包含一个 int 成员 a 和 b， 要求达到B 继承 A 的效果，也就是 B里面包含一个 A，并且能达到多态的效果， 也就是一个 A* p 指向一个指向A 调的是 A 的函数，指向 B 调的是 B 的函数 a.cpp: #include <iostream> using namespace std; class A { public: virtual void fun() {
【C++】C语言实现继承和多态
xiaoxiaoguailou的博客
03-04 2744
文章目录一、C语言实现继承二、C语言实现多态（1）静态多态（2）动态多态 一、C语言实现继承 原理：结构体组合类 //基类 typedef struct Base { //基类自身属性和方法 int b_val = 0; void show() { printf("b_val:%d\n", b_val); } }Base; typedef struct Son { //隐藏基类对象 Base base; //派生类自身属性和函数 int s_val = 10; void show()
用C语言实现C++ 继承与多态
最新发布
南风fahaxiki
10-18 499
功能，在调用创建的类函数时就十分不安全，在基类加入基类类型名和类大小成员变量可以解决这个问题。就是当创建一个类时，不需要重新编写新的数据成员和成员函数，只需指定新建的类继承了一个已有的类的成员即可。的方式，即把基类作为派生类的成员变量之一。，即只拷贝了地址，没有拷贝地址的内容。举个例子：人是动物，人具有动物的行为和属性，但人也有动物所不具备的行为和属性。在上个例子中，人和动物都有会动的属性，但人的动作和动物的动作从表现上会有所不同。就可以实现在同一个函数中，根据对象类型的不同，函数实现方式也不同。
C语言实现C++继承和多态的代码分享
08-29
C语言实现C++继承和多态的代码分享 本文主要讲诉了C和C++的区别，以及如何使用C语言模拟实现C++继承和多态，并附上示例代码。下面是相关知识点的总结： 1. C语言和C++的区别： * C语言是面向过程的语言，而C++是...
c语言实现多态
11-21
c语言实现多态
C 语言实现 C++ 多态
weixin_34293246的博客
05-09 197
C 还是 C++？ C++ 中的多态是指「通过基类对象的指针或者基类对象的引用调用虚函数」，表现更多派生类的特性，但根据 C++ 多态的实现，我们发现这种方法存在一定的空间和效率的折损。不可否认，多态轻松解决了很多工程中遇到的问题，这与 pure C 的解决方法比起来，更为优雅。 在考虑移植性上，C 的光芒要盖过 C++，但 C++ 的多态是可借鉴的，于是用 pure C 来模仿 C++ 中多...
C语言的继承与多态
Jeff_ROS的博客
11-01 508
这篇文章旨在记录自己对C语言的封装、继承与多态的学习过程，参考了CSDN上的一篇博客，本来要贴出来地址，无奈无痕浏览模式下找不到在哪里了。不过这并不影响我的分享。 对于继承和多态，我这里不做解释，看到这篇文章自然有一定的基础，解释自然是多余了。既然有基础了，那我直接上代码，供伙伴们查看和觉悟即可。 为方便无基础的伙伴，还是要提点一下关键，至少看不懂的时候，可快速自检自己的知识盲区。阅读源码的基础如下： 1. 熟悉C/C++语言，至少其中一种。 2. 了解内存模型，学习过C++的，自然看一下就明.
C语言--实现继承与多态
zwb_578209160的博客
03-02 1313
1、继承 即派生类中拥有基类的成员变量和成员函数，所以C语言实现如下： #include <stdio.h> typedef void(*Func)(void); void funB() { printf("B::funB()\n"); } typedef struct B { int _b; Func _fb; }B; typedef struct D { B b; int _d; }D; void test() { D d; d.b._fb=funB; d.
C语言实现C++继承和多态
学习使我快乐
08-23 754
C++中的多态 我们知道的是在C++中会维护一张虚函数表，根据赋值兼容规则，我们知道父类的指针或者引用是可以指向子类对象的。如果一个父类的指针或者引用调用父类的虚函数则该父类的指针会在自己的虚函数表中查找自己的函数地址，如果该父类对象的指针或者引用指向的是子类的对象，而且该子类已经重写了父类的虚函数，则该指针会调用子类的已经重写的虚函数。 //c++中的多态 class Base { pub...
C++多态、继承的简单分析
weixin_34281477的博客
05-15 85
一直以为自己对多态和继承已经比较了解，当遇到虚继承的时候，发现有点犯晕，想不通了，于是在微博上向几个大神请教，很快得到了他们的回复，高兴之情无以言表。之后自己查了一些资料，结合大神的回复，在这里做一下简单的记录。 我的问题如下： 为什么虚继承类的sizeof要大些啊，是因为虚继承中，子类有指向父类的指针和指向父类的虚函数表的指针吗，比非虚继承多了这两个指针？ @左耳朵耗子 @简悦云风 @Gen...
c语言类和继承的简单例子,c语言中继承和多态的简单实现
weixin_36125921的博客
05-21 679
C语言本身是不支持继承和多态的，但其实在 C 的世界里，有一套非常有名的面向对象的框架，用的也非常广，那就是GObject，它是整个图形界面开发库 GTK 的基石，在IBM developerWorks上有一篇很好的文章介绍 GObject《GObject对象系统》。另外，在 Linux 内核里面也大量使用了面向对象的思想，比如虚拟文件系统，设备驱动等模块，在lwn上有两篇文章就讲到了内核中的...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值