C++模板类实现带有游标的单向循环链表

最新推荐文章于 2024-09-20 21:20:45 发布
最新推荐文章于 2024-09-20 21:20:45 发布
阅读量400 收藏
点赞数
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_41836269/article/details/88431985
本文详细介绍了一种基于C++的单向循环链表实现，包括链表的基本操作如插入、删除、查找等，以及游标功能的实现，通过具体代码示例展示了如何构建和操作循环链表。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

　1，循环链表基于单向链表而生，单向链表的首尾相连，组成一个环状单。循环链表比单向链表多了游标这个概念，游标可以快速的访问当前结点和下一个结点。

   2，循环链表在插入第一个元素的时候，需要我们将第一元素的指针域指向其自身，也就构成了循环链表。

   3，循环链表在删除链表节点的时候，要注意游标，否则游标容易断开。

   4，修改循环链表时候，可以将头部，尾部，非头尾三部分分开考虑。

C++模板类实现带有游标得到单向循环链表代码如下（本次使用工具为vs2017，作者水平有限，如有bug还请指出）：

 1.模板类的头文件  Circle_List_Cplus.h

#pragma once

//定义链表结点
template<typename T>
struct ListNode
{
	struct ListNode<T> *Next;
	T data;
};

//定义循环链表模板类
template<typename T>
class Circle_List_Cplus
{
public:

	//默认构造函数，生成一个循环链表
	Circle_List_Cplus();

	//从头部插入节点
	int InsertNodeFront(T data);

	//从尾部插入节点
	int InsertNodeBack(T data);

	//从链表的任意位置插入节点
	int InsertNode(T data, int index);

	//获取任意位置节点
	T &GetListNode(int index);

	//删除任意位置节点
	int DeleteNode(int index);

	//获取链表的长度
	int GetListLen();

	//游标复位,让游标重新指向0号元素的位置
	void CursorReset();

	//根据传来的节点数据删除节点
	int Delete_From_Node(T data);

	//获取游标指向的节点位置
	T &GetCursorNode();

	//返回当前游标的节点数据，并且在游标下移动
	T &CursorNext();

	//析构函数，释放开辟的资源
	~Circle_List_Cplus();

public:
	ListNode<T> Head;		//循环链表头
	ListNode<T> Cursor;     //循环链表游标
	int         ListLen;    //循环链表长度
};

2.模板类的实现文件  Circle_List_Cplus.cpp

#include "pch.h"
#include "Circle_List_Cplus.h"
#include "iostream"
using namespace std;

//默认构造函数，生成一个循环链表
template<typename T>
Circle_List_Cplus<T>::Circle_List_Cplus()
{
	this->ListLen		= 0;
	this->Cursor.Next	= NULL;
	this->Head.Next		= NULL;
}

//从头部插入节点
template<typename T>
int Circle_List_Cplus<T>::InsertNodeFront(T data)
{
	int ret = 0;
	//创建新结点
	ListNode<T> *LNode = new ListNode<T>;

	if (LNode == NULL)
	{
		cout << " New LNode Error ：InsertNodeFront() \n" << endl;
		ret = -1;
		return ret;
	}
	if (this->ListLen == 0)				//链表表里还没有数据
	{

		LNode->data		= data;         //对于复杂数据类型，要重载=操作符
		this->Head.Next = LNode;
		LNode->Next		= LNode;
		this->ListLen++;
	}
	else
	{
		LNode->data = data;				 //对于复杂数据类型，要重载=操作符
		LNode->Next = this->Head.Next;
		this->Head.Next = LNode;
		this->ListLen++;
	}

	return ret;
}

//从尾部插入节点
template<typename T>
int Circle_List_Cplus<T>::InsertNodeBack(T data)
{
	int ret = 0;
	//创建新结点
	ListNode<T> *LNode = new ListNode<T>;
	if (LNode == NULL)
	{
		cout << " New LNode Error ：InsertNodeFront() \n" << endl;
		ret = -1;
		return ret;
	}

	if (this->ListLen == 0)  //链表表里还没有数据
	{
		LNode->data = data;         //对于复杂数据类型，要重载=操作符
		this->Head.Next = LNode;
		LNode->Next = LNode;
		this->ListLen++;
	}
	else
	{
		ListNode<T> *current = this->Head.Next;		  //current指向0号位置
		for (int i = 0; i < this->ListLen - 1; i++)   //移动到待插入位置的前面
		{
			current = current->Next;
		}
	
		LNode->data			= data;				 //对于复杂数据类型，要重载=操作符
		current->Next		= LNode;
		LNode->Next			= this->Head.Next;   //指向0号节点数据
		this->ListLen++;

	}

	return ret;
}

//从链表的任意位置插入节点
template<typename T>
int Circle_List_Cplus<T>::InsertNode(T data, int index)
{
	int ret = 0;
	//防止越界
	if (index < 0 || index > this->ListLen)
	{
		printf("Insert index error ：InsertNode() \n");
		ret = -1;
		return ret;
	}
	//创建新结点
	ListNode<T> *LNode = new ListNode<T>;
	LNode->data = data;							 //对于复杂数据类型，要重载=操作符
	ListNode<T> *current = this->Head.Next;		 //current指向0号位置

	if (this->ListLen == 0)  //链表表里还没有数据
	{
		this->Head.Next = LNode;
		LNode->Next = LNode;
		this->ListLen++;
	}
	else
	{
		if (index == 0)  //头部插入元素
		{
			LNode->Next = this->Head.Next;
			this->Head.Next = LNode;
			this->ListLen++;
		}

		else if (index == this->ListLen)			  //在尾部插入元素
		{
			for (int i = 0; i < index - 1; i++)		  //移动到待插入位置的前面
			{
				current = current->Next;
			}
			current->Next = LNode;
			LNode->Next   = this->Head.Next;
			this->ListLen++;
		}

		else
		{
			for (int i = 0; i < index - 1; i++)      //移动到待插入位置的前面
			{
				current = current->Next;
			}
			//地址链接
			LNode->Next = current->Next;
			current->Next = LNode;
			this->ListLen++;
		}
	}

	return ret;
}


//获取任意位置节点
template<typename T>
T &Circle_List_Cplus<T>::GetListNode(int index)
{
	if (index < 0 || index > this->ListLen - 1)
	{
		printf("List index error ：GetListNode() \n");
	}

	ListNode<T> *current = this->Head.Next;		    //current指向0号位置
	if (index == 0)								    //当查找的是第0号数据
	{
		return current->data;
	}
	else
	{
		for (int i = 0; i < index - 1; i++)			 //移动到待获取位置的前面
		{
			current = current->Next;
		}
		return current->Next->data;
	}

}

//删除任意位置节点
template<typename T>
int  Circle_List_Cplus<T>::DeleteNode(int index)
{
	int ret = 0;
	if (index < 0 || index > this->ListLen - 1)
	{
		printf("List index error ：DeleteNode() \n");
		ret = -1;
		return ret;
	}
	if (this->ListLen == 0)
	{
		printf("List is not exist DeleteNode() \n");
		ret = -1;
		return ret;
	}

	ListNode<T> *current = this->Head.Next;		 //current指向0号位置
	ListNode<T> *tempnode = NULL;
	if (index == 0)
	{   												 //删除了第一个位置的元素，此时要找到最后一个元素的位置
		this->Head.Next   = current->Next;				 //头节点指向1号节点
		tempnode = current;								 //记录待删除元素的位置
		this->Cursor.Next = current->Next;				 //游标指向1号节点
		for (int i = 0; i < this->ListLen - 1; i++)		 //current刚好指向最后一个元素
		{
			current = current->Next;
		}
		current->Next = this->Head.Next;
		this->ListLen--;
		//释放内存
		if (tempnode != NULL)
		{
			delete tempnode;
		}

	}
	else if (index == this->ListLen - 1)		 //删除的是最后一个节点数据
	{
		for (int i = 0; i < index - 1; i++)		 //current刚好指向最后一个元素的前面一个
		{
			current = current->Next;
		}

		tempnode = current->Next;				//缓存最后一个元素的地址，然后释放地址
		current->Next = this->Head.Next;
		this->Cursor.Next = this->Head.Next;
		this->ListLen--;
		//释放内存
		if (tempnode != NULL)
		{
			delete tempnode;
		}
	}
	else
	{
		ListNode<T> *tempnode = NULL;
		for (int i = 0; i < index - 1; i++)      //移动到待删除位置的前面
		{
			current = current->Next;
		}
		tempnode = current->Next;				 //tempnode指向待删除的位置
		current->Next = tempnode->Next;
		this->Cursor.Next = tempnode->Next;
		this->ListLen--;
		//释放内存
		if (tempnode != NULL)
		{
			delete tempnode;
		}
	}

	return ret;
}

//获取链表的长度
template<typename T>
int  Circle_List_Cplus<T>::GetListLen()
{
	return this->ListLen;
}

//游标复位,让游标重新指向0号元素的位置
template<typename T>
void  Circle_List_Cplus<T>::CursorReset()
{
	this->Cursor.Next = this->Head.Next;
}


//根据传来的节点数据删除节点
template<typename T>
int Circle_List_Cplus<T>::Delete_From_Node(T data)
{
	int ret = 0;
	int tag = 0;
	int i   = 0;
	ListNode<T> *current = this->Head.Next;		 //current指向0号位置
	for (i = 0; i < this->ListLen; i++)		     //循环玩之后在cuurrent在最后一个位置
	{
		if (current->data == data)				//注意对于复杂数据类型，这里要重载==操作符
		{
			tag = 1;
			break;
		}
		current = current->Next;
	}
	if (tag == 1)
	{
		DeleteNode(i);    //删除元素
	}
	else
	{
		cout << "Not find data to delete" << endl;
		ret = -1;
		return ret;
	}

	return ret;
}

//获取游标指向的节点位置
template<typename T>
T& Circle_List_Cplus<T>::GetCursorNode()
{
	//链表为空
	if (this->Head.Next == 0)
	{
		cout << "List is empty" << endl;
	}

	return this->Cursor.Next->data;
}

//返回当前游标的节点数据，并且在游标下移动
template<typename T>
T& Circle_List_Cplus<T>::CursorNext()
{
	//链表为空
	if (this->Head.Next == 0)
	{
		cout << "List is empty" << endl;
	}

	ListNode<T> *temp = this->Cursor.Next;		 //获取当前的游标，在最后一个位置
	this->Cursor.Next = temp->Next;			     //游标指向
	return temp->data;
}

//释放资源
template<typename T>
Circle_List_Cplus<T>::~Circle_List_Cplus()
{
	ListNode<T> *current = this->Head.Next;      //current指向0号位置
	ListNode<T> *temp	 = current->Next;	     //temp指向1号位置

	for (int i=0; i<this->ListLen-1; i++)
	{
		if (current != NULL)
		{
			delete current;
		}
		current = temp;
		temp = current->Next;
	}

	this->Cursor.Next = NULL;
	this->ListLen   = 0;
	this->Head.Next   = NULL;
}

3.循环链表的测试文件 _Circle_List_Cplus_Framecpp.cpp

#include "pch.h"
#include "Circle_List_Cplus.cpp"
#include "iostream"
#include "string"
using namespace std;

//自定义人类
class person
{
public:
	person()
	{
	
	}

	person(string name,int age)
	{
		this->name = name;
		this->age = age;
	}

	person(const person &obj)
	{
		this->name = obj.name;
		this->age = obj.age;
	}

	//重载=
	person & operator=(person &obj)
	{
		this->name = obj.name;
		this->age = obj.age;
		return *this;
	}
	//重载==
	bool operator==(person &obj)
	{
		if (this->name == obj.name && this->age == obj.age)
		{
			return true;
		}
		else
		{
			return false;
		}
	}

	~person()
	{
	
	
	}

public:
	int age;
	string name;
};

//打印链表的信息
void printf_person(Circle_List_Cplus<person> &obj)
{
	cout << "--------------开始打印数据---------------" << endl;
	person data;
	int tag = 0;
	for (int i = 0; i < 2 * obj.ListLen; i++)
	{
		if (i == obj.ListLen)
		{
			printf("----第%d次打印数据---- \n", tag + 1);
			i = 0;
			tag++;
		}
		if (tag == 2)
		{
			break;
		}
		data = obj.GetListNode(i);
		cout << data.name << "    " << data.age << endl;
		printf("\n");
	}
	cout << "--------------结束打印数据---------------" << endl;
}
//测试链表的增删改查，以及游标功能
void test2()
{
	person p1("pxzz", 21), p2("wxxx", 22), p3("iut", 23), p4("dft", 24), p5("hji", 25), p6("kij", 26), p7("kio", 27);
	Circle_List_Cplus<person> CLC;
	person dd;
	
	//测试插入节点
	CLC.InsertNodeFront(p1);
	CLC.InsertNodeFront(p2);
	CLC.InsertNodeBack(p3);
	CLC.InsertNodeBack(p4);
	CLC.InsertNode(p5, 0);
	CLC.InsertNode(p6, 5);
	printf_person(CLC);

	//测试删除节点
	CLC.DeleteNode(5);
	CLC.DeleteNode(0);
	CLC.DeleteNode(1);
	printf_person(CLC);

	//测试游标移动和获取功能
	CLC.CursorReset();

	dd = CLC.GetCursorNode();

	cout << dd.name << "      "<< dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	printf_person(CLC);
	//测试给定数据删除数据
	CLC.Delete_From_Node(p2);
	printf_person(CLC);


	//测试游标移动和获取功能
	CLC.CursorReset();

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

	dd = CLC.CursorNext();
	cout << dd.name << "      " << dd.age << endl;

}
//主函数
int main()
{
	test2();
	system("pause");
	return 0;
}

 

pxz_wxx
关注
VIVO C++开发面试题及参考答案
大模型大数据攻城狮的专栏
12-24 7768
运算符重载是 C++ 的一个重要特性，它允许我们重新定义运算符对于自定义类型的操作方式。运算符重载的定义是对已有的运算符赋予新的含义，使其能够操作自定义的数据类型。例如，对于一个复数类，我们可以重载加法运算符。
数据结构 模板化的链表类 包括对链表基本操作 链表游标的使用实例
12-21
数据结构 模板化的链表类 包括对链表基本操作 链表游标的使用实例
C++模板类实现带有游标的双向链表
qq_41836269的博客
03-13 359
链表只能从头结点开始访问链表中的数据元素，如果需要逆序访问单链表中的数据元素将极其低效。双链表是链表的一种，由节点组成，每个数据结点中都有两个指针，分别指向直接后继和直接前驱，带有游标的双向链表可以应用在某些特殊的场景。 详细讲解参照https://www.bilibili.com/video/av27904891/?p=1 本次使用工具为vs2017，作者水平有限，若有问题请指出。 链表模板...
动态游标for循环_数据结构系列循环链表
weixin_39928844的博客
12-06 269
前面留的一个问题,后文更跟新回答单链表可以表示任意的线性关系，有些线性关系是循环的，既没有队尾元素。将单链表中的终端结点指针端由空指针改为指向头结点，这时的单链表形成国恒一个环，改为循环链表。插入与删除与单链表的原理甚至一模一样，工程CircleListPro，将单链表改成循环链表。CircleList.h文件ifndef _CIRCLELIST_H_#defin...
循环链表
Keep coding
08-26 468
单链表的局限 单链表可以用于表示任意的线性关系 有些线性关系是循环的，即没有队尾元素 循环链表的定义将单链表中最后一个数据元素的next指针指向第一个元素循环链表拥有单链表的所有操作 创建链表 销毁链表 获取链表长度 清空链表 获取第pos个元素操作 插入元素到位置pos 删除位置pos处的元素 游标的定义在循环链表中可以定义一个“当前”指针，这个指针通常称为游标，可以通过这个游标（slider）来
C/C++ 单链表的游标实现（完整代码）
ylh的博客
12-23 377
不使用任何指针类型，利用游标实现单链表的基本操作，增删改查等各种基本操作
模板链表类实现与游标使用教程
模板化链表类允许我们创建单向链表、双向链表或循环链表等，这些链表可以用来存储任意类型的数据，比如整数、浮点数、字符串或甚至是复杂的对象。 2. **链表基本操作**：链表的基本操作通常包括创建链表、插入节点...
请使用模板参数设计实现单向链表模板类LinkList，应能根据需求构建相应类型数据结点的单向链表结构，main(void)完成对其的测试。 设计要求： (1)设计实现结点模板类Node，结点的数据域应能各种类型数据；其中成员函数getData(void)的作用是获取结点的数据域。构造函数输出信息“Node Constructor run”，拷贝构造函数输出信息“Node CopyConstructor run”，析构函数输出信息“Node Destructor run” (2)在结点模板类Node的支持下设计实现结点单向链表模板类LinkList，其中： ①LinkList类的数据包括结点链表的头结点headNode和游标position（游标用于表示当前操作位置） ②有参构造函数实现由数组构建链表的功能，构造函数输出信息“LinkList Constructor run”；拷贝构造函数输出信息“LinkList CopyConstructor run”，析构函数输出信息“LinkList Destructor run” ③设计实现成员函数insertNode(n)，其功能为在游标位置后插入一个同类型结点n。 ④设计实现成员函数searchNode(value)，其功能为在链表中查找数据域等于value的结点，若查找成功的同时修改游标位置。 ⑤设计实现成员函数getSize()，其功能为返回链表中的元素个数。 ⑥设计实现成员函数next()，其功能为使游标移动到下一个结点。 ⑦设计实现成员函数currNode()const，其功能为返回当前结点。 ⑧设计实现成员函数delNode()，其功能为移除当前结点。 ⑨设计实现成员函数show()，其功能为输出链表。 提示： 1 g++下定义模板类时，成员函数名不要带模板参数； 2 delete只能删除new产生的结点 裁判测试程序样例： #include <iostream> using namespace std; /*请在这里填写答案*/ int main() { int i,a[5]= {0,1,2,3,4}; for(i=0;i<5;i++) scanf("%d",&a[i]); LinkList<int> l1(a,5),l2(l1); cout<<l2.getSize()<<endl; l1.show(); if (l2.searchNode(2)) cout<<"Found:"<<l2.currNode().getData()<<endl; else cout<<"Not Found"<<endl; l2.delNode(); Node <int> *p1=new Node<int>(11); l2.insertNode(*p1); l2.show(); return 0; } 输入样例： 1 2 3 4 5 输出样例： Node Constructor run Node Constructor run Node Constructor run Node Constructor run Node Constructor run Node Constructor run LinkList Constructor run Node Constructor run Node Constructor run Node Constructor run Node Constructor run Node Constructor run Node Constructor run LinkList CopyConstructor run 5 [1][2][3][4][5] Found:2 Node Constructor run [1][11][3][4][5] Node Destructor run Node Destructor run Node Destructor run Node Destructor run Node Destructor run LinkList Destructor run Node Destructor run Node Destructor run Node Destructor run Node Destructor run Node Destructor run Node Destructor run LinkList Destructor run Node Destructor run
最新发布
05-11
好的，我现在需要帮助用户解决如何用C++实现一个支持多种数据类型的单向链表模板类LinkList的问题。首先，我得回顾一下用户提供的引用内容，看看有没有相关的信息可以参考。 用户引用了三个关于模板类成员函数定义...
C/C++面试宝典2024版(最新版)
热门推荐
学无止尽，谨言慎行！
04-02 3万+
面试基础前言new、delete、malloc、free关系delete与 delete []区别C和C++ 的共同点？不同之处？继承的优缺点C++有哪些性质（面向对象特点）子类析构时要调用父类的析构函数吗？多态，虚函数，纯虚函数求下面函数的返回值（微软）什么是“引用”？申明和使用“引用”要注意哪些问题？将“引用”作为函数参数有哪些特点？在什么时候需要使用“常引用”？将“引用”作为函数返回值类型的...
数据结构（从概念到C++实现）
m0_54285007的博客
09-05 7174
目录 第2章 线性表 2.1 引言 2.2 线性表的逻辑结构 2.2.1 线性表的定义 2.2.2 线性表的抽象数据类型定义 第2章 线性表 2.1 引言 线性表是描述单一的前驱和后继的关系 2.2 线性表的逻辑结构 2.2.1 线性表的定义 线性表是一个有限的序列，每个元素有且只有一个前驱和一个 后继，表头和表尾元素分别无前驱和后继。 线性表数据元素的个数称为线性表的长度，长度为0的线性表称为空表 线性表的常用表达方式为：L=(a1,a2,a3,a4....an) 2.2.
游标实现链表
lancelot0902的博客
06-11 377
List_cursor.h #ifndef LIST_CURSOR_H #define LIST_CURSOR_H constexpr auto MAX_SPACE = 10;; #include <iostream> using namespace std; struct Node { int data; int next; }; class List { public: Li...
链表的游标实现（最全面）
GaoJieVery6
03-08 738
代码的主体来自于《Data Structures and Algorithm Analysis in C (Second Edition)》，我在书中代码的基础上进行了一些修改与补充。修改 补充 说明：1.  添加了Last变量，代表链表的最后一个元素的下标，使IsEmpty( )等函数的实现更为直观，快捷。2.  增加了FindPrevious,Print,Out三个函数，使API更为完善。3....
算法学习 - 链表的游标实现~ C++
累了就歇一会
07-27 3646
链表的游标实现，就是用另外一种方法来访问链表，模拟游标。 在我学习的理解中，就是创建一个节点数组，模拟内存的排列，然后从其中来申请内存和释放内存。但是实际的内存没有被释放~
第十课，循环链表
wuyadeCS的专栏
06-21 498
专题三：渐入佳境。包括以下章节： 无招胜有招-静态链表 气宗门道-循环链表 剑宗门道-双向链表 课后练习 单链表的局限 单链表可以用于表示任意的线性关系 有些线性关系是循环的，即没有队尾元素 单链表的改进循环链表的定义 将单链表中最后一个数据元素的next指针指向第一个元素 循环链表的操作循环链表拥有单链表的所有操作 创建链表 销毁链表 获取链表长度 清空链表 获取第pos个元素操作 插入元素到位置
数据结构-循环链表（学习笔记）
maweisky531的专栏
08-12 429
定义： 将单链表中最后一个数据元素的next指针指向第一个元素 游标： 在循环链表中可以定义一个“当前”指针，这个指针通常称为游标，可以通过这个游标来遍历链表中的所有元素。 一些新的操作： 1.获取当前游标指向的数据元素 2.将游标重置指向链表中的第一个数据元素 3.将游标移动指向到链表中的下一个数据元素 4.直接指定删除链表中的某个数据元素 头文件: #ifn
Proc *C/C++入门之游标访问数据库
lzjsqn的专栏
01-11 1758
数据类型转换 Oracle外部数据类型中的string是以零结尾的字符串，类似于varchar2类型！ char在数据不满的时候，后面部分会被填充为空格 在SQL语句中的宿主数据类型可以人为的转换为Oracle的外部数据类型，所以我们可以把char [20]转换为string类型，避免产生多余的空格虽然varchar也可以避免空格，但是varchar还要引用里卖弄具体的成员，所以不是很方便，最方便的
数据结构之循环链表
CCDreamOldBoys的专栏
07-28 786
一、循环链表的定义 将单链表中最后一个数据元素的next指针指向第一个元素 二、循环链表的功能和操作方法 创建链表销毁链表获取链表长度清空链表获取第pos个元素操作插入元素到位置pos删除位置pos处的元素 相对于单项链表来说，增加了一个控制部分游标进行控制节点，其主要操作是控制循环链表的初始化；可以通过游标指针来进行遍历； 注意说明： 1.
单链表类模板的实现190918
ShenHang_的博客
09-18 444
#include<iostream> using namespace std; template<class T> class Node { private: Node<T> * next; public: T data; ...
c++ 防坑！获取控制台光标（游标）坐标
我是Python虫！！！
09-20 376
c++ 避坑：GetConsoleCursorPosition获取游标坐标是假的！
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值