c语言通过宏实现类似c++的泛型编程效果——泛型链表

最新推荐文章于 2026-06-30 00:03:29 发布
原创 最新推荐文章于 2026-06-30 00:03:29 发布 · 483 阅读 · 2 ·
本内容遵循CC 4.0 BY-SA版权协议
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
GEO检测
收录于
c笔记

当前文章被收录于：

c笔记
4 篇文章 0 人学习
订阅专栏 查看详情
本文介绍了如何使用C语言通过宏定义实现泛型链表，包括节点结构、链表结构以及查找、添加、删除和更改操作。虽然提高了代码复用性，但调试难度增加，可通过宏展开辅助调试。

序言：在学了c++之后，突然间想能不能用c来模拟实现一个泛型链表。

直接进入正题。

众所周知，c++在定义了一个模板后，如果在使用了一个类型的模板函数或类，编译器在编译时会自动创建该类型的函数或类。

而我们如果想使用c实现泛型，可以用宏来定义一个模板（幸好c的代码缩进没有严格要求），如果我们要用不同类型的函数，我们可以手动去定义。

上代码"list.h"

#pragma once

#include <stdint.h>
#include <stdbool.h>
#include <malloc.h>


#define LLNODE(type) struct type##_llnode{struct type##_llnode* next;type e;};
#define LLIST(type) struct type##_llist{struct type##_llnode* list;int num;};
#define LLFIND(type) bool type##_llfind(struct type##_llist* L,int pos,type * e);
#define LLADD(type) bool type##_lladd(struct type##_llist* L,int pos,type e);
#define LLDELETE(type) bool type##_lldelete(struct type##_llist* L,int pos);
#define LLCHANGE(type) bool type##_llchange(struct type##_llist* L,int pos,type e);
#define INCLUDE_LL(type) LLNODE(type) LLIST(type) LLFIND(type) LLADD(type) LLDELETE(type) LLCHANGE(type)

#define POS_LEGAL_LORO(pos,b,e) ((pos>=b)&&(pos<(int)(e)))
#define POS_LEGAL_LORC(pos,b,e) ((pos>=b)&&(pos<=(int)(e)))

#define LLFIND_FUN(type) bool type##_llfind(struct type##_llist* L,int pos,type * e)\
{\
	if(!POS_LEGAL_LORO(pos,0,L->num))return false;\
	if(e == NULL)return false;\
	struct type##_llnode* node = L->list;\
	for(int i = 0;i<pos;i++)node = node->next;\
	*e = node->e;\
	return true;\
}

#define LLADD_FUN(type) bool type##_lladd(struct type##_llist* L,int pos,type e)\
{\
	if(!POS_LEGAL_LORC(pos,0,L->num))return false;\
	struct type##_llnode* n = (struct type##_llnode *)malloc(sizeof(struct type##_llnode));\
	if(n == NULL)return false;\
	n->next = NULL;\
	n->e = e;\
    if (pos == 0) \
	{\
		n->next = L->list;\
		L->list = n;\
		L->num++;\
		return true;\
	}\
	struct type##_llnode* node = L->list;\
	for(int i = 0;i<pos-1;i++)node = node->next;\
	n->next = node->next;\
	node->next = n;\
	L->num++;\
	return true;\
}

#define LLDELETE_FUN(type) bool type##_lldelete(struct type##_llist* L,int pos)\
{\
	if(!POS_LEGAL_LORO(pos,0,L->num))return false;\
	struct type##_llnode* n = L->list;\
    if (pos == 0) \
	{\
		L->list = n->next;\
		free(n);\
		L->num--;\
		return true;\
	}\
	struct type##_llnode* node = L->list;\
	for(int i = 0;i<pos-1;i++)node = node->next;\
	n = node->next;\
	node->next = n->next;\
	free(n);\
	L->num--;\
	return true;\
}

#define LLCHANGE_FUN(type) bool type##_llchange(struct type##_llist* L,int pos,type e)\
{\
	if(!POS_LEGAL_LORO(pos,0,L->num))return false;\
	struct type##_llnode* node = L->list;\
	for(int i = 0;i<pos;i++)node = node->next;\
	node->e = e;\
	return true;\
}

#define SOURCE_LL(type) LLFIND_FUN(type) LLADD_FUN(type) LLDELETE_FUN(type) LLCHANGE_FUN(type)

#define LLcreate(type,name) struct type##_llist name = {NULL,0}
#define LLlen(L) ((L)->num)
#define LLfind(type) type##_llfind
#define LLadd(type) type##_lladd
#define LLdelete(type) type##_lldelete
#define LLchange(type) type##_llchange
#define LLpush_back(type,l,e) type##_lladd(l,(l)->num,e)
#define LLpop_up(type,l) type##_lldelete(l,((l)->num - 1))

INCLUDE_LL(int)
INCLUDE_LL(float)

 

#define LLNODE(type) struct type##_llnode{struct type##_llnode* next;type e;};
#define LLIST(type) struct type##_llist{struct type##_llnode* list;int num;};
#define LLFIND(type) bool type##_llfind(struct type##_llist* L,int pos,type * e);
#define LLADD(type) bool type##_lladd(struct type##_llist* L,int pos,type e);
#define LLDELETE(type) bool type##_lldelete(struct type##_llist* L,int pos);
#define LLCHANGE(type) bool type##_llchange(struct type##_llist* L,int pos,type e);
#define INCLUDE_LL(type) LLNODE(type) LLIST(type) LLFIND(type) LLADD(type) LLDELETE(type) LLCHANGE(type)

↑这是链表类以及它的方法的模板，INCLUDE_LL(type)是声明，好让我们能够去使用这些操作，不过我在下面定义了更便于去使用的方法

#define POS_LEGAL_LORO(pos,b,e) ((pos>=b)&&(pos<(int)(e)))
#define POS_LEGAL_LORC(pos,b,e) ((pos>=b)&&(pos<=(int)(e)))

↑这是确定pos是否合法的宏，POS_LEGAL_LORO左开右开区间  POS_LEGAL_LORC左开右闭区间 

#define LLFIND_FUN(type) bool type##_llfind(struct type##_llist* L,int pos,type * e)\
{\
	if(!POS_LEGAL_LORO(pos,0,L->num))return false;\
	if(e == NULL)return false;\
	struct type##_llnode* node = L->list;\
	for(int i = 0;i<pos;i++)node = node->next;\
	*e = node->e;\
	return true;\
}

#define LLADD_FUN(type) bool type##_lladd(struct type##_llist* L,int pos,type e)\
{\
	if(!POS_LEGAL_LORC(pos,0,L->num))return false;\
	struct type##_llnode* n = (struct type##_llnode *)malloc(sizeof(struct type##_llnode));\
	if(n == NULL)return false;\
	n->next = NULL;\
	n->e = e;\
    if (pos == 0) \
	{\
		n->next = L->list;\
		L->list = n;\
		L->num++;\
		return true;\
	}\
	struct type##_llnode* node = L->list;\
	for(int i = 0;i<pos-1;i++)node = node->next;\
	n->next = node->next;\
	node->next = n;\
	L->num++;\
	return true;\
}

#define LLDELETE_FUN(type) bool type##_lldelete(struct type##_llist* L,int pos)\
{\
	if(!POS_LEGAL_LORO(pos,0,L->num))return false;\
	struct type##_llnode* n = L->list;\
    if (pos == 0) \
	{\
		L->list = n->next;\
		free(n);\
		L->num--;\
		return true;\
	}\
	struct type##_llnode* node = L->list;\
	for(int i = 0;i<pos-1;i++)node = node->next;\
	n = node->next;\
	node->next = n->next;\
	free(n);\
	L->num--;\
	return true;\
}

#define LLCHANGE_FUN(type) bool type##_llchange(struct type##_llist* L,int pos,type e)\
{\
	if(!POS_LEGAL_LORO(pos,0,L->num))return false;\
	struct type##_llnode* node = L->list;\
	for(int i = 0;i<pos;i++)node = node->next;\
	node->e = e;\
	return true;\
}

#define SOURCE_LL(type) LLFIND_FUN(type) LLADD_FUN(type) LLDELETE_FUN(type) LLCHANGE_FUN(type)

↑方法实例模板，SOURCE_LL(type)用于创建方法实例

#define LLcreate(type,name) struct type##_llist name = {NULL,0}
#define LLlen(L) ((L)->num)
#define LLfind(type) type##_llfind
#define LLadd(type) type##_lladd
#define LLdelete(type) type##_lldelete
#define LLchange(type) type##_llchange
#define LLpush_back(type,l,e) type##_lladd(l,(l)->num,e)
#define LLpop_up(type,l) type##_lldelete(l,((l)->num - 1))

↑便于我们使用的一些方法，包括创建表头，获取链表长度，增删查改，以及尾删和尾插。使用起来类似于函数重载，函数名固定，但是，参数类型不同，不过我们要显性的指明类型，如：我要往一个float元素的链表插入一个元素，我们必须有这样写，

LLadd(float)(&list,0,1.32);

这样写LLadd有点像返回函数指针的函数😁

使用方法：

        在一个头文件加入INCLUDE_LL（type）,实例化声明，type是你要使用的类型，如：

在“list.h"声明

INCLUDE_LL(int)
INCLUDE_LL(float)

        同时在一个源文件加入SOURCE_LL(type)，实例化方法，如：

#include "llist.h"

SOURCE_LL(int)

SOURCE_LL(float)

这样就可以使用了

#include "llist.h"
#include <stdio.h>

int main()
{
	LLcreate(float, L);
	LLpush_back(float, &L, 3.32);
	LLpush_back(float, &L, 2.34);
	LLadd(float)(&L, 0, 1.32);
	LLadd(float)(&L, 0, 324.456);
	for (float i = 0,ip = 0; i < LLlen(&L); i++)
	{
		LLfind(float)(&L, i,&ip);
		printf("%f\n", ip);
	}
	putchar('\n');
	LLpop_up(float, &L);
	for (float i = 0, ip = 0; i < LLlen(&L); i++)
	{
		LLfind(float)(&L, i, &ip);
		printf("%f\n", ip);
	}

	return 0;
}

窗口打印：

 

定义链表元素类型type时可以是任何类型，前提是用宏模板手动去定义了这套类和方法

这样写的好处是，提高了代码的复用率，用起来更加舒服，但是带来的后果就是调试困难（不过幸好vs有宏展开功能，在使用时无法大脑模拟调试是可以用宏展开来调试）

不过这只是一种c泛型编程的写法，还可以用void*来实现，不过缺点还是，需要在使用时时刻记住你使用的是什么类型

标签
#c语言 #c++ #开发语言 #链表
泛型Lambda，如此强大！
编程与实战的博客
01-17 1301
最近发现泛型编程有了另一利器——泛型Lambda，比想象当中要强大许多，威力不小，和大家分享一下。本篇内容需要对泛型编程有所了解，若是读过之前更新的相关文章，食用更佳。1泛型编程开始之前，...
深入剖析无头单链表——C语言动图演示
一些七零八碎的知识点
03-14 3806
深度剖析单链表——C语言实现。简单易懂，源码附上
C++宏的作用与C#里宏的代替(三)
u011974126的专栏
08-20 5773
6、宏组合  #和## 先上一段代码： #include "stdafx.h" #include using namespace std; #define s5(a) Connect_##a #define s(p) #p void Connect_Test(const char* p) { cout << "this is Connect Test:" << endl;
C++接口实现总结
qimo601的专栏
02-04 1292
网上的例子，稍微有点错误。我给更改一下，附件上有源码！如有错误，请指正。 总结一下C++实现接口的技巧。       面向对象的语言诸如JAVA提供了Interface来实现接口，但C++却没有这样一个东西，尽管C++ 通过纯虚基类实现接口，譬如COM的C++实现就是通过纯虚基类实现的（当然MFC的COM实现用了嵌套类），但我们更愿意看到一个诸如 Interface的东西。下面就介绍一种解决办...
链表的表示和实现
widhxbkz的博客
08-31 92
【代码】链表的表示和实现。
关于C之泛型
itzyjr的专栏
11-09 1950
C11新增了一种表达式，叫作泛型选择表达式。 在程序设计中，泛型编程（generic programming）指那些没有特定类型，但是一旦指定一种类型，就可以转换成指定类型的代码。例如，C++在模板中可以创建泛型算法，然后编译器根据指定的类型自动使用实例化代码。在C中这个功能是C11版本才具有的，可根据表达式的类型（即表达式的类型是int、double 还是其他类型）选择一个值。泛型选择表达式不...
浅谈C++模板与泛型编程
Canger_的博客
08-23 1105
一、如何进行泛型编程： C/C++是一种静态编程语言，必须需要把代码翻译成可执行的二进制可执行程序然后在运行，一旦编译好之后就不能再变了(数据类型确定后就无法更改，因此要为每一种数据类型编写一份算法) + C语言中的快速排序： void qsort(void *base, size_t nmemb, size_t size,int(*compar)(const void *, const...
C语言中的泛型尝试：void_ + 函数指针
always_TT的博客
04-08 517
摘要 本文探讨了在C语言中实现泛型编程的技术，主要使用void*指针和函数指针来创建类型无关的代码。通过两个示例展示了泛型排序函数和泛型链表的实现方法：1) 泛型冒泡排序函数通过void*接收数组，配合比较函数实现任意类型排序；2) 泛型链表使用void*存储数据，并依赖用户提供的打印和释放函数处理不同类型。这些技术模拟了高级语言的泛型特性，提高了C语言代码的复用性和灵活性。文章包含代码示例、流程图和外部参考链接，帮助读者理解和应用这一重要编程范式。
C++中的多态在C中如何实现
firefly_2002的专栏
09-18 4625
多态的含义约等同于“同一个方法对于不同类型的输入参数均能做出正确的处理过程，并给出人们所期望获得的结果” C++的多态性是C++实现面向对象技术的基础。具体的说，通过一个指向基类的指针调用虚成员函数的时候， 运行时系统将能够根据指针所指向的实际对象调用恰当的成员函数实现。 一、要用C模拟C++的多态性，可定义同一种函数指针类型和函数指针，运行过程中根据需要给函数指针赋函数地址 如下
填一个大坑之C/C++实现线性表（利用泛型）下篇
jamenu的博客
04-03 501
ding
C/C++编程笔记：图书管理系统（C语言链表），项目源码献上
致力于C语言C++知识分享！
10-07 1286
大学C语言课程设计——图书管理系统（C语言版本） 必不可缺的头文件： #define _CRT_SECURE_NO_WARNINGS #include <stdio.h> #include <stdlib.h> #include <string.h> #include <iostream> #include <list> using namespace std; 源码分享： #define _CRT_SECURE_NO_W
C语言：实现单链表的就地逆置
weixin_46695826的博客
04-06 3977
近日，笔者使用CFree编译器，实现了单链表的就地逆置。 单链表，顾名思义，就是链式存储的线性表，是C与C++的学习中必须掌握的内容之一。 代码如下： #include <stdio.h> #include <stdlib.h> #include <string.h> #include <assert.h> #include <stddef.h...
C C++最全真不戳,基于C++泛型编程的职工管理系统(2)，C C++开发自学技巧
m0_51437227的博客
05-15 776
void savelink() {//--------------------------------------存链表。void savelink() {//--------------------------------------存链表。~link() {//--------------------------------------------销毁链表。~link() {//--------------------------------------------销毁链表。
c语言实现cpp中的引用传递
为了部落！
04-09 2375
C语言不存在按引用传递，一切都是按值传递。 这是由C语言的特点决定的，C语言中不需要按引用传递，因为指针技术完全可以理所当然地实现同样的目的。 而C#和Java 这类不允许指针的语言，就必须区别这两种传递方式。 在C中，唯一容易弄混的地方是，传递的参数是数组，如下： void fun(char *s,int a) {} 或者 void fun(char s[],int a) {} 首
Go泛型编程
最新发布
星航夜空的帆舟
06-30 226
泛型是Go 1.18版本引入的重大语言特性，它让Go程序员能够编写类型安全且可复用的代码。本文参考了Go官方泛型教程（go.dev/doc/tutorial/generics）、Go官方博客（go.dev/blog/generic-interfaces）以及社区最佳实践，系统地讲解了类型参数、类型约束、泛型函数和泛型类型的概念与用法。
概念梳理：C和C++关于链表的构建差异和拓展想法
Aer_7z的博客
04-12 2139
本篇文章主要记录的是本人在C++的学习过程中产生的浅薄见解，涉及到C语言的链表讲解（结构体）、C++的链表讲解（类）还有二者之间的对比差异和优势。
数据结构C++的&引用怎怎么在C语言实现同样的功能
maojiaoliang的博客
04-18 1864
对于很多只学过C语言，没学过的C++的小伙伴，在刚开始学习数据结构的时候，会遇到C++引用“&”的概念，我们为什么使用它，简单的来说：一般实参能将本身的值传给形参，但我们修改形参之后，形参却不能将修改后的值传回给实参，这个过程是单向传递的过程. 具体实例看如下 #include<stdio.h> void sum(int x) { x = x + 1; printf("%d\n", x); } main() { int x = 5; printf("%d\n",..
用C写有面向对象特点的程序
weixin_34223655的博客
06-12 169
为什么80%的码农都做不了架构师？>>> ...
C语言编程学习：链表的来源分析
debet2014的博客
06-10 147
C语言是面向过程的，而C＋＋是面向对象的 C和C++的区别： C是一个结构化语言，它的重点在于算法和数据结构。C程序的设计首要考虑的是如何通过一个过程，对输入（或环境条件）进行运算处理得到输出（或实现过程（事务）控制）。 C++，首要考虑的是如何构造一个对象模型，让这个模型能够契合与之对应的问题域，这样就可以通过获取对象的状态信息得到输出或实现过程（事务）控制。 所以C与C++的最...
2023，我与C/C++相遇的奇迹之年
Code Space
12-29 4518
记录一下我踏入计算机世界的起始年，分享一路上的感悟与酸甜苦辣，这一路有志同道合的伙伴同行，留下了太多的美好，我很珍惜。2023，我与C/C++相遇的奇迹之年就此落下帷幕，而希望，仍在远方眺望。最后，提前祝福大家新年快乐啦，新的一年写代码没有bug，写题目秒出思路哦！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值