循环单链表（C语言版）

最新推荐文章于 2022-10-29 13:38:00 发布
最新推荐文章于 2022-10-29 13:38:00 发布
阅读量1.6w 收藏 182
点赞数 23
分类专栏： 数据结构与算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_44075108/article/details/108969625
版权

前言

小可爱们，本次一起来看看循环单链表吧，嘻嘻！

一、循环单链表的定义

        循环单链表是单链表的另一种形式，其结构特点链表中最后一个结点的指针域不再是结束标记，而是指向整个链表的第一个结点，从而使链表形成一个环。和单链表相同，循环链表也有带头结点结构和不带头结点结构两种，带头结点的循环单链表实现插入和删除操作较为方便。

二、循环单链表的结构

1、结构图
在这里插入图片描述

2、代码表示

#define ElemType int

typedef struct Node
{
	ElemType data; //数据域
	struct Node *next; //指针域
}Node, *PNode;
//循环链表管理结点
typedef struct List
{
	PNode first; //指向头结点
	PNode last; //指向尾结点
	int   size;
}List;

三、循环单链表的常用操作

1、初始化

//初始化循环单链表
void InitSCList(List *list)
{
	//申请头结点
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	//将链表管理结点中的头指针和尾指针分别指向这个结点
	list->first = list->last = s;
	//将尾结点的下一个结点指向头结点形成循环
	list->last->next = list->first;
	//此时存有数据的结点个数为0
	list->size = 0;
}

2、获取结点

//获取结点 x为存入结点内的数据
Node* _buynode(ElemType x)
{
	//申请结点
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	//存放数据
	s->data = x;
	s->next = NULL;
	return s;
}

3、尾插

//尾插
void push_back(List *list, ElemType x)
{
	Node *s = _buynode(x);//获取一个结点
	list->last->next = s;//将该结点插入
	list->last = s;//更改管理结点中尾结点的指向
	list->last->next = list->first;//重新形成环状
	list->size++;//将有效结点数加一
}

4、头插

//头插
void push_front(List *list, ElemType x)
{
	Node *s = _buynode(x);//获取结点
	//将结点插入
	s->next = list->first->next;
	list->first->next = s;
	//如果这是一个有效结点，那么需要更改管理结点中尾指针的指向
	if(list->first == list->last)
	{
		list->last = s;
	}
	list->size++;//有效结点数加一
}

5、数据显示

//查看链表内的所有数据
void show_list(List *list)
{
	Node *p = list->first->next;//指向有效结点部分
	while(p != list->first)//将有效结点内的数据输出
	{
		printf("%d-->",p->data);
		p = p->next;//下移
	}
	printf("Nul.\n");
}

6、尾删

//尾删
void pop_back(List *list)
{
	//如果没有可删除的有效结点则退出
	if(list->size == 0)
		return;
	//查找要删除结点的上一结点
	Node *p = list->first;
	while(p->next != list->last)
	{
		p = p->next;
	}
	//删除尾结点
	free(list->last);
	//将之前查找到的结点(倒数第二个结点)设置为新的尾结点
	list->last = p;
	list->last->next = list->first;//重新形成环
	list->size--;//有效结点数减一
}

7、头删

//头删
void pop_front(List *list)
{
	//如果没有有效结点可删除则退出
	if(list->size == 0)
		return;
	//删除有效头结点
	Node *p = list->first->next;
	list->first->next = p->next;
	free(p);
	//如果此时链表内只有一个有效结点，那么需要改变尾指针的指向
	if(list->size == 1)
	{
		list->last = list->first;
	}
	list->size--;//将有效结点数减一
}

8、按值插入(按照升序插入)

//按值插入(按照升序插入)
void insert_val(List *list, ElemType x)
{
	//寻找结点的插入位置
	Node *p = list->first;
	while(p->next!=list->last && p->next->data < x)
	{
		p = p->next;
	}
	//如果插入位置在尾部，那么进行尾插，否则在中间插入
	if(p->next == list->last && p->next->data < x)
	{
		push_back(list,x);//尾插
	}
	else
	{
		//中间插入
		Node *s = _buynode(x);
		s->next = p->next;
		p->next = s;
		list->size++;
	}
}

9、按值查找

//查找
Node* find(List *list, ElemType key)
{
	//如果没有有效数据结点则无需查找
	if(list->size == 0)
		return NULL;
	//从有效结点的首位置进行查找
	Node *p = list->first->next;
	while(p != list->first && p->data!=key)
		p = p->next;

	//如果没有找到，返回空
	if(p == list->first)
		return NULL;
	//如果找到，返回结点地址
	return p;
}

10、求有效结点个数

//求链表有效结点个数
int  length(List *list)
{
	return list->size;
}

11、按值删除

//按值删除
void delete_val(List *list, ElemType key)
{
	//如果不存在有效结点，那么无需进行删除
	if(list->size == 0)
		return;
	//查找要删除结点的位置
	Node *p = find(list,key);
	//如果没有查找到则无需删除
	if(p == NULL)
	{
		printf("要删除的数据不存.\n");
		return;
	}
	//如果要删除结点是尾结点，那么可进行尾删
	if(p == list->last)
	{
		pop_back(list);
	}
	else //如果在中间位置，那么把要删除结点的下一结点拷贝到当前要删除结点，然后删除下一结点
	{
		Node *q = p->next;
		//把要删除结点的下一结点拷贝到当前要删除结点
		p->data = q->data;
		p->next = q->next;
		//删除下一结点
		free(q);
		list->size--;//有效结点数减一
	}
}

12、按升序排序

//升序排列
void sort(List *list)
{
	//判断是否要进行排序（有效结点数小于等于1个不进行排序）
	if(list->size==0 || list->size==1)
		return;
	
	Node *s = list->first->next;//指向第一个有效结点
	Node *q = s->next;//指向第二个有效结点

	//将原来的循环链表断开，形成一个只含一个有效结点的循环链表和一个单链表
	list->last->next = NULL;//单链表的尾结点指向空
	list->last = s;
	list->last->next = list->first;

	while(q != NULL) //将单链表内的有效结点逐一按照值插入方式（升序的值插入）插入到循环链表中
	{
		//从单链表中拿下一个有效结点
		s = q;
		q = q->next;

		//查找插入的位置
		Node *p = list->first;
		while(p->next!=list->last && p->next->data < s->data)
		{
			p = p->next;
		}
		//如果插入位置在尾部，那么进行尾插，否则在中间插入
		if(p->next == list->last && p->next->data < s->data)
		{
			s->next = list->last->next;
			list->last->next = s;
			list->last = s;
		}
		else
		{
			//中间插入
			s->next = p->next;
			p->next = s;
		}
	}
}

13、逆置

//逆置
void resver(List *list)
{
	//判断是否要进行逆置（有效结点数小于等于1个不进行逆置）
	if(list->size==0 || list->size==1)
		return;
	Node *p = list->first->next;//指向第一个有效结点
	Node *q = p->next;//指向第二个有效结点

	//将原来的循环链表断开，形成一个只含一个有效结点的循环链表和一个单链表
	list->last->next = NULL;//单链表的尾结点指向空
	list->last = p;                    
	list->last->next = list->first;

	while(q != NULL)//将单链表内的有效结点逐一头插到循环链表中
	{
		//从单链表中拿下一个有效结点
		p = q;
		q = q->next;
		//头插
		p->next = list->first->next;
		list->first->next = p;
	}
}

14、清空循环单链表

//清除有效结点
void clear(List *list)
{
	Node *p = list->first->next;//指向第一个有效结点
	while(p != list->first)//将所有有效结点释放清除
	{
		list->first->next = p->next;
		free(p);
		p = list->first->next;
	}
	//设置管理结点中的尾结点指向和头结点的指针域指向
	list->last = list->first;
	list->last->next = list->first;
	list->size = 0;//有效结点数为0
}

15、销毁循环单链表

//销毁循环链表
void destroy(List *list)
{
	clear(list);//先清除所有有效结点
	free(list->first);//清除头结点
	list->first = list->last = NULL;
}

总结

        循环单链表是一种链式存储结构，它是由单链表改进而来的。把单链表改为循环单链表的过程是将它的尾结点next指针域由原来为空改为指向头结点，整个单链表形成一个环。由此，从表中任一个结点出发均可以找到链表中的其他结点。

附录

以下提供源码测试

Main.cpp

#include"SCList.h"

void main()
{
	List mylist;
	InitSCList(&mylist);

	ElemType Item;
	Node *p = NULL;
	int select = 1;
	while(select)
	{
		printf("**************************************\n");
		printf("* [1] push_back      [2] push_front  *\n");
		printf("* [3] show_list      [4] pop_back    *\n");
		printf("* [5] pop_front      [6] insert_val  *\n");
		printf("* [7] find           [8] length      *\n");
		printf("* [9] delete_val     [10] sort       *\n");
		printf("* [11] resver        [12] clear      *\n");
		printf("* [13*] destroy       [0] quit_system*\n");
		printf("**************************************\n");
		printf("请选择:>");
		scanf("%d",&select);
		if(select == 0)
			break;
		switch(select)
		{
		case 1:
			printf("请输入要插入的数据(-1结束):>");
			while(scanf("%d",&Item),Item != -1)
			{
				push_back(&mylist,Item);
			}
			break;
		case 2:
			printf("请输入要插入的数据(-1结束):>");
			while(scanf("%d",&Item),Item != -1)
			{
				push_front(&mylist,Item);
			}
			break;
		case 3:
			show_list(&mylist);
			break;
		case 4:
			pop_back(&mylist);
			break;
		case 5:
			pop_front(&mylist);
			break;
		case 6:
			printf("请输入要插入的数据:>");
			scanf("%d",&Item);
			insert_val(&mylist,Item);
			break;
		case 7:
			printf("请输入要查找的数据:>");
			scanf("%d",&Item);
			p = find(&mylist,Item);
			if(p == NULL)
			{
				printf("要查找的数据在链表中不存在.\n");
			}
			break;
		case 8:
			printf("单链表的长度为:> %d \n",length(&mylist));
			break;
		case 9:
			printf("请输入要删除的值:>");
			scanf("%d",&Item);
			delete_val(&mylist,Item);
			break;
		case 10:
			sort(&mylist);
			break;
		case 11:
			resver(&mylist);
			break;
		case 12:
			clear(&mylist);
			break;
		//case 13:
		//	destroy(&mylist);
		//	break;
		default:
			printf("输入的命令错误,请重新输入.\n");
			break;
		}
	}
	destroy(&mylist);
}

SCList.h

#ifndef __SCLIST_H__
#define __SCLIST_H__

#include<stdio.h>
#include<malloc.h>
#include<assert.h>

#define ElemType int

typedef struct Node
{
	ElemType data; //数据域
	struct Node *next; //指针域
}Node, *PNode;
//循环链表管理结点
typedef struct List
{
	PNode first; //指向头结点
	PNode last; //指向尾结点
	int   size;
}List;

Node* _buynode(ElemType x);

void InitSCList(List *list);

void push_back(List *list, ElemType x);
void push_front(List *list, ElemType x);
void show_list(List *list);

void pop_back(List *list);
void pop_front(List *list);
void insert_val(List *list, ElemType x);
Node* find(List *list, ElemType key);
int  length(List *list);
void delete_val(List *list, ElemType key);
void sort(List *list);
void resver(List *list);
void clear(List *list);
void destroy(List *list);

#endif //__SCLIST_H__

SCList.cpp


#include"SCList.h"
//获取结点 x为存入结点内的数据
Node* _buynode(ElemType x)
{
	//申请结点
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	//存放数据
	s->data = x;
	s->next = NULL;
	return s;
}
//初始化循环单链表
void InitSCList(List *list)
{
	//申请头结点
	Node *s = (Node *)malloc(sizeof(Node));
	assert(s != NULL);
	//将链表管理结点中的头指针和尾指针分别指向这个结点
	list->first = list->last = s;
	//将尾结点的下一个结点指向头结点形成循环
	list->last->next = list->first;
	//此时存有数据的结点个数为0
	list->size = 0;
}
//尾插
void push_back(List *list, ElemType x)
{
	Node *s = _buynode(x);//获取一个结点
	list->last->next = s;//将该结点插入
	list->last = s;//更改管理结点中尾结点的指向
	list->last->next = list->first;//重新形成环状
	list->size++;//将有效结点数加一
}
//头插
void push_front(List *list, ElemType x)
{
	Node *s = _buynode(x);//获取结点
	//将结点插入
	s->next = list->first->next;
	list->first->next = s;
	//如果这是一个有效结点，那么需要更改管理结点中尾指针的指向
	if(list->first == list->last)
	{
		list->last = s;
	}
	list->size++;//有效结点数加一
}
//查看链表内的所有数据
void show_list(List *list)
{
	Node *p = list->first->next;//指向有效结点部分
	while(p != list->first)//将有效结点内的数据输出
	{
		printf("%d-->",p->data);
		p = p->next;//下移
	}
	printf("Nul.\n");
}
//尾删
void pop_back(List *list)
{
	//如果没有可删除的有效结点则退出
	if(list->size == 0)
		return;
	//查找要删除结点的上一结点
	Node *p = list->first;
	while(p->next != list->last)
	{
		p = p->next;
	}
	//删除尾结点
	free(list->last);
	//将之前查找到的结点(倒数第二个结点)设置为新的尾结点
	list->last = p;
	list->last->next = list->first;//重新形成环
	list->size--;//有效结点数减一
}
//头删
void pop_front(List *list)
{
	//如果没有有效结点可删除则退出
	if(list->size == 0)
		return;
	//删除有效头结点
	Node *p = list->first->next;
	list->first->next = p->next;
	free(p);
	//如果此时链表内只有一个有效结点，那么需要改变尾指针的指向
	if(list->size == 1)
	{
		list->last = list->first;
	}
	list->size--;//将有效结点数减一
}
//按值插入(按照升序插入)
void insert_val(List *list, ElemType x)
{
	//寻找结点的插入位置
	Node *p = list->first;
	while(p->next!=list->last && p->next->data < x)
	{
		p = p->next;
	}
	//如果插入位置在尾部，那么进行尾插，否则在中间插入
	if(p->next == list->last && p->next->data < x)
	{
		push_back(list,x);//尾插
	}
	else
	{
		//中间插入
		Node *s = _buynode(x);
		s->next = p->next;
		p->next = s;
		list->size++;
	}
}
//查找
Node* find(List *list, ElemType key)
{
	//如果没有有效数据结点则无需查找
	if(list->size == 0)
		return NULL;
	//从有效结点的首位置进行查找
	Node *p = list->first->next;
	while(p != list->first && p->data!=key)
		p = p->next;

	//如果没有找到，返回空
	if(p == list->first)
		return NULL;
	//如果找到，返回结点地址
	return p;
}

//求链表有效结点个数
int  length(List *list)
{
	return list->size;
}
//按值删除
void delete_val(List *list, ElemType key)
{
	//如果不存在有效结点，那么无需进行删除
	if(list->size == 0)
		return;
	//查找要删除结点的位置
	Node *p = find(list,key);
	//如果没有查找到则无需删除
	if(p == NULL)
	{
		printf("要删除的数据不存.\n");
		return;
	}
	//如果要删除结点是尾结点，那么可进行尾删
	if(p == list->last)
	{
		pop_back(list);
	}
	else //如果在中间位置，那么把要删除结点的下一结点拷贝到当前要删除结点，然后删除下一结点
	{
		Node *q = p->next;
		//把要删除结点的下一结点拷贝到当前要删除结点
		p->data = q->data;
		p->next = q->next;
		//删除下一结点
		free(q);
		list->size--;//有效结点数减一
	}
}
//升序排列
void sort(List *list)
{
	//判断是否要进行排序（有效结点数小于等于1个不进行排序）
	if(list->size==0 || list->size==1)
		return;
	
	Node *s = list->first->next;//指向第一个有效结点
	Node *q = s->next;//指向第二个有效结点

	//将原来的循环链表断开，形成一个只含一个有效结点的循环链表和一个单链表
	list->last->next = NULL;//单链表的尾结点指向空
	list->last = s;
	list->last->next = list->first;

	while(q != NULL) //将单链表内的有效结点逐一按照值插入方式（升序的值插入）插入到循环链表中
	{
		//从单链表中拿下一个有效结点
		s = q;
		q = q->next;

		//查找插入的位置
		Node *p = list->first;
		while(p->next!=list->last && p->next->data < s->data)
		{
			p = p->next;
		}
		//如果插入位置在尾部，那么进行尾插，否则在中间插入
		if(p->next == list->last && p->next->data < s->data)
		{
			s->next = list->last->next;
			list->last->next = s;
			list->last = s;
		}
		else
		{
			//中间插入
			s->next = p->next;
			p->next = s;
		}
	}
}
//逆置
void resver(List *list)
{
	//判断是否要进行逆置（有效结点数小于等于1个不进行逆置）
	if(list->size==0 || list->size==1)
		return;
	Node *p = list->first->next;//指向第一个有效结点
	Node *q = p->next;//指向第二个有效结点

	//将原来的循环链表断开，形成一个只含一个有效结点的循环链表和一个单链表
	list->last->next = NULL;//单链表的尾结点指向空
	list->last = p;                    
	list->last->next = list->first;

	while(q != NULL)//将单链表内的有效结点逐一头插到循环链表中
	{
		//从单链表中拿下一个有效结点
		p = q;
		q = q->next;
		//头插
		p->next = list->first->next;
		list->first->next = p;
	}
}
//清除有效结点
void clear(List *list)
{
	Node *p = list->first->next;//指向第一个有效结点
	while(p != list->first)//将所有有效结点释放清除
	{
		list->first->next = p->next;
		free(p);
		p = list->first->next;
	}
	//设置管理结点中的尾结点指向和头结点的指针域指向
	list->last = list->first;
	list->last->next = list->first;
	list->size = 0;//有效结点数为0
}
//销毁循环链表
void destroy(List *list)
{
	clear(list);//先清除所有有效结点
	free(list->first);//清除头结点
	list->first = list->last = NULL;
}
红心火柴
关注
  • 23
    点赞
  • 踩
  • 182
    收藏
    觉得还不错? 一键收藏
  • 8
    评论
专栏目录
【数据结构】 循环单链表的基本操作 （C语言版）
weixin_56814370的博客
01-21 971
【数据结构】 循环单链表的基本操作 （C语言版）
数据结构之循环链表（C语言）
sskdspdl的博客
09-03 736
用C语言实现循环链表
数据结构之单向循环链表
yjhqukq的博客
10-29 2314
单向循环链表与单向链表的结点结构相同，每个结点都有一个数据域、一个指针域。数据域用来存储结点的数据，指针域用来存储下一个结点所在的内存空间地址。两者不同的是，单向链表末结点的指针域为NULL，而单向循环链表末结点的指针域存储了头结点所在的内存空间地址。这里实现了单向循环链表的六个基本功能，初始化链表、添加结点(头插法、尾插法)、删除结点、反转链表、遍历链表。
使用C语言实现循环单链表（带头节点）
Keep_Trying_Go的博客
08-07 1628
使用C语言实现循环单链表
循环单链表的实现c语言
better_xiong的博客
06-21 1734
1.循环单链表和单链表的区别在于链表中最后一个结点的指针不是指向NULL，而是指向头结点，这样链表结点就形成了一个环。循环单链表是一个环，所以在链表中任意位置插入或者删除结点时都是等价的，不需要根据所操作结点是否是尾结点分类讨论，因此简化了代码。 2.下面是循环单链表的具体操作详细代码，由c语言实现。 #include<stdio.h> #include<malloc.h> #define ElemType int typedef struct LinkNode{ ElemTy
循环单链表（C语言实现）
Mr_John
10-26 518
#include<stdio.h> #include<stdlib.h> #include<stdbool.h> typedef int DataType; typedef struct Node { DataType data; // 数据域 struct Node * next; // 指针域 }LinkList; LinkList* Init_List(); // ...
C语言实现的循环单链表功能示例
08-27
C语言实现的循环单链表功能示例 本文主要介绍了C语言实现的循环单链表功能，结合实例形式分析了基于C语言实现的循环单链表定义、创建、添加、删除、打印、排序等相关操作技巧。 一、循环单链表的定义 在C语言中，...
C语言 循环单链表的简单操作
09-11
循环单链表是一种常见的数据结构，它在C语言中被广泛用于实现各种算法和数据管理。循环单链表与普通单链表的主要区别在于最后一个节点的指针不再为NULL，而是指向链表的第一个节点，形成了一个环状结构。这种结构在...
数据结构 C语言实现循环单链表的实例
08-30
数据结构 C语言实现循环单链表的实例 数据结构是计算机科学中的一门重要学科，它研究的是数据的存储、表示和操作的方法。在计算机科学中，数据结构是指数据的组织、存储和操作的方法。循环单链表是一种常见的数据...
C语言线性表--单链表
qq_35732321的博客
06-01 158
main.c SingleLinkList.h 3 SingleLinkList.c
循环链表源代码
05-01
循环链表源代码，自己分配内存，没有用任何STL的东西。
约瑟夫环问题（循环单链表）
兔子王
09-21 1392
约瑟夫环问题：N个人围成一圈，从第一个开始报数，第M个将被杀掉，最后剩下一个，其余人都将被杀掉。例如N=6，M=5，被杀掉的顺序是：5，4，6，2，3，1。
C语言中单向循环链表与双向循环链表详解
qq_41835250的博客
07-26 5195
每日一句 It’s gonna be ok. 一切都会好的。 内容概要 单向循环链表 首先来看看图示： 图展示的是一个单向循环链表，他跟以上的单向链表对比只是多了一个指向头结点的 指针，因此，他们的算法几乎是一样的。 第一，设计节点。 单向循环链表的节点跟单向链表完全一致。 第二，初始化空链表。 跟单向链表类似，我们既可以初始化一个带有头结点的空循环链表，也可以不要头结点： 这边把两个步骤放在一起了 linklist init_list(void) // 带有头结点的单循环链表 { linklis
循环单链表的结构和定义
Fenice
02-26 1140
#include "stdafx.h" #include using namespace std; #include enum Status{OK,ERROR}; typedef int ElemType; typedef struct Lnode { ElemType num; ///结点元素类型为int Lnode *next;
数据结构_单循环链表_C语言实现
m0_59519697的博客
05-09 556
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录二、使用步骤1.引入库2.读入数据总结 单循环链表 如果把单链表的最后一个节点的指针指向链表头部，而不是指向NULL，那么就构成了一个单向循环链表，通俗讲就是把尾节点的下一跳指向头结点。 初始化 typedef struct Node { int data; struct Node* next; }Node; Node* initList() { Node* L = (Node*)malloc(s.
【C语言】单向循环链表（实例详解约瑟夫问题）
m0_60511809的博客
11-27 4015
类似单链表，循环链表也是一种链式的存储结构，由单链表演化而来。 单向循环链表来源于单链表，所以单链表的基本操作基本都适合于循环链表。两者的不同点主要表现在链表的建立和链表表尾的判断。 接下来我们通过分析一个经典的问题即 “ 约瑟夫问题 ”来理解单循环链表。 “ 约瑟夫问题 ” 简单来说就是：有n个人围成一个圈，规定一个数字num，从某个人开始报数，每次从1报到这个数字num，报到num的人出列，现在要我们按顺序输出...
数据结构学习笔记-循环链表（C语言实现）
Daydream Mr.的博客
02-23 984
  循环链表的概念主要就是让单链表的尾节点的指针不为空并且指向头节点。像这样的循环链表和普通单链表除了判断条件几乎没有任何区别，判断条件就是从p-&gt;next是否为空改为p-&gt;next是否等于头节点，如果等于头节点则循环结束。#include &lt;stdio.h&gt; #include &lt;stdlib.h&gt; typedef int Eletype; typedef st...
C语言建立循环单链表并输出
Xenoverse的博客
12-12 5703
Description  依次输入n（n&gt;0)个整数，建立带表头结点的循环单链表，并依次输出单链表中的元素值。 提示： 结点结构如下： typedef struct Node {      int data;       struct Node *next; }LNode,*LinkList; 要求： （1）编写函数，从键盘输入n个数，建立带头结点的循环单链表。  （2...
循环单链表的基本操作
罗小黑の窝
04-30 766
循环单链表所尊崇的结点如图 所实现的功能如下： void InitList(List *list);//初始化 bool push_back(List *list, ElemType x);//尾插 bool push_front(List *list, ElemType x);//头插 bool pop_back(List *list);//尾删 bool pop_front
#define eleType int啥意思
最新发布
06-16
#define eleType int 是预处理器指令，它定义了一个宏常量 eleType 并将其设置为整型（int）。在 C 或 C++ 编程中，这样的宏定义被用来替换代码中的某个标识符，使得在后续的代码中，无论何时引用 eleType，都会被替换成 int。这通常用于统一类型或简化类型声明，特别是在函数参数、数组声明或结构体中，可以减少重复的类型定义。例如： ```cpp typedef struct { eleType value; } MyStruct; void myFunction(MyStruct s) { // 在这里，eleType 被隐式地理解为 int } ```
评论 8
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值