WIN32下Socket最简单的实现,Select模型,IOCP_demo

最新推荐文章于 2024-04-27 15:05:51 发布
最新推荐文章于 2024-04-27 15:05:51 发布
阅读量697 收藏 1
点赞数
分类专栏： Linux服务器开发 Windows服务器 文章标签： 网络 服务器 tcp/ip
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/A_With_better/article/details/126053608
版权

目录

Socket

服务器

#pragma warning(disable:4996)
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#ifdef WIN32
#include <WinSock2.h>
#include <Windows.h>
#pragma comment (lib, "WSOCK32.LIB")
#endif

#define IP "127.0.0.1"
#define PORT 6080

int main(int argc, char** argv)
{
#ifdef WIN32	//配置win socket 版本
	WORD wVersionRequested;
	WSADATA wsaData;
	wVersionRequested = MAKEWORD(2, 2);
	int ret = WSAStartup(wVersionRequested, &wsaData);
	if (ret != 0)
	{
		printf("WSAStart up error\n");
		return -1;
	}
#endif

	int listenfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (listenfd == INVALID_SOCKET)
	{
		goto failed;
	}

	struct sockaddr_in sockaddr;
	sockaddr.sin_addr.S_un.S_addr = inet_addr(IP);
	sockaddr.sin_family = AF_INET;
	sockaddr.sin_port = htons(PORT);

	ret = bind(listenfd, (const struct sockaddr*)&sockaddr, sizeof(sockaddr));
	if (ret != 0)
	{
		goto failed;
	}

	ret = listen(listenfd, 1);

	while (1)
	{
		struct sockaddr_in c_address;
		int address_len = sizeof(c_address);
		printf("Waiting...");
		int client_fd = accept(listenfd, (struct sockaddr*)&c_address, &address_len);
		printf("new client comming...! %s：%d\n", inet_ntoa(c_address.sin_addr), ntohs(c_address.sin_port));

		char buf[11];
		memset(buf, 0, 11);
		recv(client_fd, buf, 5, 0);

		printf("recv: %s\n", buf);

		send(client_fd, buf, 5, 0);

		closesocket(client_fd);
	}
failed:
	if (listenfd != INVALID_SOCKET)
	{
		closesocket(listenfd);
	}
#ifdef WIN32
	WSACleanup();
#endif
	return 0;
}

客户端

#pragma warning(disable:4996)
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#ifdef WIN32
#include <WinSock2.h>
#include <Windows.h>
#pragma comment (lib, "WSOCK32.LIB")
#endif

#define IP "127.0.0.1"
#define PORT 6080

int main(int argc, char** argv)
{
#ifdef WIN32	//配置win socket 版本
	WORD wVersionRequested;
	WSADATA wsaData;
	wVersionRequested = MAKEWORD(2, 2);
	int ret = WSAStartup(wVersionRequested, &wsaData);
	if (ret != 0)
	{
		printf("WSAStart up error\n");
		return -1;
	}
#endif
	int s = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (s == -1)
	{
		printf("create socket error!\n");
		goto falise;
	}
	struct sockaddr_in sockaddr;
	sockaddr.sin_addr.S_un.S_addr = inet_addr(IP);
	sockaddr.sin_family = AF_INET;
	sockaddr.sin_port = htons(PORT);

	ret = connect(s, (struct sockaddr*)&sockaddr, sizeof(sockaddr));
	if (ret != 0)
	{
		goto falise;
	}

	char buff[11];
	memset(buff, 0, 11);
	send(s, "Hello", 5, 0);
	recv(s, buff, 5, 0);
	printf("recv: %s", buff);

falise:
	if (s != INVALID_SOCKET)
	{
		closesocket(s);
		s = INVALID_SOCKET;
	}

#ifdef WIN32
	WSACleanup();
#endif
	return 0;
}

上述方法一次只能接入一个连接.下面使用select

select

定义一个句柄集合

fd_set set;

清空

FD_ZERO(&set);

将监听句柄加入到等待集合里面

FD_SET(listenfd, &set);  // 将监听句柄加入到等待集合里面

设置select

ret = select(0, &set, NULL, NULL, NULL); //读事件
if (ret < 0)
{
	printf("select error\n");
	continue;
}
else if (ret == 0)  //超时, 参数5决定, NULL表示阻塞
{
	printf("select timeout\n");
	continue;
}

判断句柄是否有新事件

//main外,demo用,接入的客户端会单独管理,这里存到数组以作为演示
static int client_fd[4096];  //保存连接句柄
static int socket_count = 0;
//--------------------------
if (FD_ISSET(listenfd, &set))//发送过来了新的连接请求数据
{
	struct sockaddr_in c_address;
	int address_len = sizeof(c_address);
	printf("Waiting...");
	int cs_fd= accept(listenfd, (struct sockaddr*)&c_address, &address_len);
	printf("new client comming...! %s：%d\n", inet_ntoa(c_address.sin_addr), ntohs(c_address.sin_port));

	client_fd[socket_count] = cs_fd;
	socket_count++;
	continue;
}

将新的客户端链接句柄加入到等待集合中

//将新的客户端链接句柄加入到等待集合中
for (int j = 0; j < socket_count; j++)
{
FD_SET(client_fd[j], &set);
}

历所有的客户端句柄, 判断连接句柄有没有读事件

//遍历所有的客户端句柄, 判断连接句柄有没有读事件
for (int j = 0; j < socket_count; j++)
{

	if (client_fd[j] != INVALID_SOCKET && FD_ISSET(client_fd[j], &set))//有读事件
	{
		char buff[1024];
		ret = recv(client_fd[j], buff, sizeof(buff), 0);
		if (ret <= 0)  //客户端关闭
		{
			closesocket(client_fd[j]);
			client_fd[j] = INVALID_SOCKET;
		}
		else
		{
			buff[ret] = 0;
			printf("%s\n", buff);
			send(client_fd[j], buff, ret, 0);
		}
	}

}

完整代码

#pragma warning(disable:4996)
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#ifdef WIN32
#include <WinSock2.h>
#include <Windows.h>
#pragma comment (lib, "WSOCK32.LIB")
#endif

#define IP "127.0.0.1"
#define PORT 6080

static int client_fd[4096];  //保存连接句柄
static int socket_count = 0;

int main(int argc, char** argv)
{
#ifdef WIN32	//配置win socket 版本
	WORD wVersionRequested;
	WSADATA wsaData;
	wVersionRequested = MAKEWORD(2, 2);
	int ret = WSAStartup(wVersionRequested, &wsaData);
	if (ret != 0)
	{
		printf("WSAStart up error\n");
		return -1;
	}
#endif

	int listenfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
	if (listenfd == INVALID_SOCKET)
	{
		goto failed;
	}

	struct sockaddr_in sockaddr;
	sockaddr.sin_addr.S_un.S_addr = inet_addr(IP);
	sockaddr.sin_family = AF_INET;
	sockaddr.sin_port = htons(PORT);

	ret = bind(listenfd, (const struct sockaddr*)&sockaddr, sizeof(sockaddr));
	if (ret != 0)
	{
		goto failed;
	}

	ret = listen(listenfd, 1);

	fd_set set;

	while (1)
	{
		FD_ZERO(&set);
		FD_SET(listenfd, &set);  // 将监听句柄加入到等待集合里面

		//将新的客户端链接句柄加入到等待集合中
		for (int j = 0; j < socket_count; j++)
		{
			if (client_fd[j] != INVALID_SOCKET)
				FD_SET(client_fd[j], &set);
		}

		ret = select(0, &set, NULL, NULL, NULL);
		if (ret < 0)
		{
			printf("select error\n");
			continue;
		}
		else if (ret == 0)  //超时, 参数5决定, NULL表示阻塞
		{
			printf("select timeout\n");
			continue;
		}

		//判断句柄事件
		if (FD_ISSET(listenfd, &set))//发送过来了新的连接请求数据
		{
			struct sockaddr_in c_address;
			int address_len = sizeof(c_address);

			int cs_fd = accept(listenfd, (struct sockaddr*)&c_address, &address_len);
			printf("new client comming...! %s：%d\n", inet_ntoa(c_address.sin_addr), ntohs(c_address.sin_port));

			client_fd[socket_count] = cs_fd;
			socket_count++;
			continue;
		}
		//遍历所有的客户端句柄, 判断连接句柄有没有读事件
		for (int j = 0; j < socket_count; j++)
		{

			if (client_fd[j] != INVALID_SOCKET && FD_ISSET(client_fd[j], &set))//有读事件
			{
				char buff[1024];
				ret = recv(client_fd[j], buff, sizeof(buff), 0);
				if (ret <= 0)  //客户端关闭
				{
					closesocket(client_fd[j]);
					client_fd[j] = INVALID_SOCKET;
				}
				else
				{
					buff[ret] = 0;
					printf("%s\n", buff);
					send(client_fd[j], buff, ret, 0);
				}
			}

		}
	}
failed:
	if (listenfd != INVALID_SOCKET)
	{
		closesocket(listenfd);
	}
#ifdef WIN32
	WSACleanup();
#endif
	return 0;
}

select缺点

1: 性能不好,每次有事件的时候都要遍历所有的句柄,然后查是哪个句柄的事件;
2: 能够管理的句柄的数目是有限制的, 2048个
3: socket的读和写仍然是同步的, 我们发送和接受数据的时候会等在网卡上面;

IOCP管理模型

1: IOCP: 是windows针对高性能服务器做的IO的管理模式，又叫完成端口;
2: IOCP的核心模式:

 1>提交请求;
 2>等待结果;
 3>继续提交请求;

3: 监听:

 1>提交一个监听请求,使用完成端口来等待这个请求到来;
 2>请求来了后，处理，继续提交请求;

4: 读取数据:

 1>提交一个读取数据的请求。
 2>请求完成后，处理完后继续提交;

5: 发送数据的请求:

 1>提交一个发送数据的请求;
 2>请求完成后，继续处理;

IOCP

#pragma warning(disable:4996)
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

#include <WinSock2.h>
#include <mswsock.h>
#include <windows.h> 

#pragma comment(lib, "WSOCK32.lib ")
#pragma comment(lib, "ws2_32.lib")
#pragma comment(lib, "odbc32.lib")
#pragma comment(lib, "odbccp32.lib")

#define IP "127.0.0.1"
#define PORT 6080

enum
{
	IOCP_ACCEPT = 0,  //监听socket,接入请求
	IOCP_RECV,        //读请求
	IOCP_WRITE		  //写请求
};

//接受数据时候最大的buf大小;
#define MAX_RECV_SIZE 8192

struct io_package
{
	WSAOVERLAPPED overlapped;
	int opt;                   //操作类型, 监听, 读, 写, IOCP_ACCEPT/IOCP_RECV/IOCP_WRITE
	int accept_sock;           //提交请求的句柄, accept的句柄或是读写请求的句柄
	WSABUF wsabuffer;		   //配合读写数据时候用的buffer
	char pkg[MAX_RECV_SIZE];   //定义了一个buff, 这个buff就是真正的内存
};

//投递一个用户请求
static void
post_accept(SOCKET l_sock)
{
	//分配一个io_package 数据结构
	struct io_package* pkg_data = (struct io_package*)malloc(sizeof(struct io_package));
	memset(pkg_data, NULL, sizeof(struct io_package));

	//初始化接受数据的buf
	pkg_data->wsabuffer.buf = pkg_data->pkg;
	pkg_data->wsabuffer.len = MAX_RECV_SIZE - 1;
	pkg_data->opt = IOCP_ACCEPT;  //请求类型

	DWORD dwBytes = 0;
	SOCKET client = WSASocket(AF_INET, SOCK_STREAM, IPPROTO_TCP, NULL, 0, WSA_FLAG_OVERLAPPED);
	int addr_size = (sizeof(struct sockaddr_in) + 16);
	pkg_data->accept_sock = client;

	AcceptEx(l_sock, client, pkg_data->wsabuffer.buf, 0,
		addr_size, addr_size, &dwBytes, &pkg_data->overlapped);
}

static void
post_recv(SOCKET client_fd)
{
	struct io_package* io_data = (struct io_package*)malloc(sizeof(struct io_package));
	memset(io_data, NULL, sizeof(struct io_package));

	io_data->opt = IOCP_RECV;
	io_data->wsabuffer.buf = io_data->pkg;
	io_data->wsabuffer.len = MAX_RECV_SIZE - 1;
	io_data->accept_sock = client_fd;

	DWORD dwRecv = 0;
	DWORD dwFlags = 0;
	//异步读数据
	int ret = WSARecv(client_fd, &(io_data->wsabuffer),
		1, &dwRecv, &dwFlags,
		&(io_data->overlapped), NULL);

}

int main(int argc, char** argv)
{
	WORD wVersionRequested;
	WSADATA wsaData;
	wVersionRequested = MAKEWORD(2, 2);
	int ret = WSAStartup(wVersionRequested, &wsaData);
	if (ret != 0)
	{
		printf("WSAStart up error\n");
		return -1;
	}

	SOCKET l_sock = INVALID_SOCKET;

	//创建一个完成端口
	HANDLE iocp = CreateIoCompletionPort(INVALID_HANDLE_VALUE, NULL, 0, 0);
	if (iocp == INVALID_HANDLE_VALUE)
	{
		goto failed;
	}

	//创建socket
	l_sock = socket(AF_INET, SOCK_STREAM, 0);
	if (l_sock == INVALID_SOCKET)
	{
		goto failed;
	}

	struct sockaddr_in s_address;
	memset(&s_address, 0, sizeof(s_address));
	s_address.sin_family = AF_INET;
	s_address.sin_addr.s_addr = inet_addr(IP);
	s_address.sin_port = htons(PORT);

	if (bind(l_sock, (struct sockaddr*)&s_address, sizeof(s_address)))
		goto failed;

	if (listen(l_sock, SOMAXCONN) != 0)
		goto failed;

	//IOCP管理l_sock
	//参数三: 用户传入的自定义数据
	CreateIoCompletionPort((HANDLE)l_sock, iocp, (DWORD)0, 0);
	//发送一个监听用户进来的请求
	post_accept(l_sock);

	while (1)
	{
		DWORD dwTrans; //当有数据读到时, 读到的数据数量大小
		DWORD udata;   //用户数据
		struct io_package* io_data;
		// 通过完成端口, 来获得这个请求的结果
		// 调用操作系统的API函数, 查看哪个请求完成了
		// 如果没有状态完成, 那么任务会挂起
		ret = GetQueuedCompletionStatus(iocp, &dwTrans,
			&udata, (LPOVERLAPPED*)&io_data, WSA_INFINITE);

		if (ret == 0)
		{
			if (io_data && io_data->opt == IOCP_RECV)
			{
				closesocket(io_data->accept_sock);
				//关闭socket
				free(io_data);
				continue;
			}
			else if (io_data->opt == IOCP_ACCEPT)
			{
				free(io_data);
				post_accept(l_sock);
			}
		}

		if (dwTrans == 0 && io_data->opt == IOCP_RECV)  //读请求
		{
			closesocket(io_data->accept_sock);
			//关闭socket
			free(io_data);
			continue;
		}

		switch (io_data->opt)
		{
		case IOCP_ACCEPT:  // 接入一个socket
		{
			int client_fd = io_data->accept_sock;  //接入的client_socket
			int addr_size = (sizeof(struct sockaddr_in) + 16);
			struct sockaddr_in* l_addr = NULL;
			int l_len = sizeof(struct sockaddr_in);

			struct sockaddr_in* r_addr = NULL;
			int r_len = sizeof(struct sockaddr_in);

			//可以拿到端口和地址
			GetAcceptExSockaddrs(io_data->wsabuffer.buf,
				0, addr_size, addr_size,
				(struct sockaddr**)&l_addr, &l_len,
				(struct sockaddr**)&r_addr, &r_len);

			// 将新进来的client_fd, 加入完成端口, 来帮助管理完成的请求
			// 第三个参数是用户自定义数据, 可以携带自己的数据结构
			CreateIoCompletionPort((HANDLE)client_fd, iocp, (DWORD)client_fd, 0);
			//投递一个读的请求;
			post_recv(client_fd);
			free(io_data);
			//重新投递一个接受请求;
			post_accept(l_sock);
		}
		break;
		case IOCP_RECV:
		{
			// dwTrans : 读到的数据大小
			// socket : io_data->accept_sock
			// Buf : io_data->wsabuffer.buf/pkg
			io_data->pkg[dwTrans] = 0;
			printf("IOCP recv %d : %s\n", dwTrans, io_data->pkg);

			//直接投递下一个请求
			DWORD dwRecv = 0;
			DWORD dwFlags = 0;

			int ret = WSARecv(io_data->accept_sock, &(io_data->wsabuffer),
				1, &dwRecv, &dwFlags,
				&(io_data->overlapped), NULL);
		}
		break;
		}
	}

failed:
	if (l_sock)
	{
		closesocket(l_sock);
	}

	if (iocp != INVALID_HANDLE_VALUE)
	{
		CloseHandle(iocp);  //释放完成端口
	}
	WSACleanup();
	return 0;
}
方池安夏
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
windows下select和socket配合实现多路复用技术
03-14
windows 下用c实现聊天平台需要解决的问题
Win32项目 C++利用socket实现C/S客户端间群聊和私聊
04-27
本项目利用socket技术 在win32平台上 利用C++语言 可以实现客户端间群聊和私聊的功能 IP地址为本地IP地址
socket select()用法
winson的专栏
03-15 2501
一、winsock中#include 原型int select(int nfds,fd_set* readfds,fd_set* writefds,fd_set* exceptfds,const struct timeval* timeout);nfds：本参数忽略，仅起到兼容作用。   readfds：（可选）指针，指向一组等待可读性检查的套接口。   writefds：（可选）
WinSocket模型的探讨——select模型
一雨田的专栏
01-18 9405
查找了很多资料都找不到select模型的详细用法，《Windows网络编程》这本书上也只是写了一个简单的回应服务器，就连writefds的用法都没讲，也不知道什么时候利用“可写”来发文件。这些都是我的疑问，相信很多研究网络编程的同路人也碰到了我的这些问题。这些疑问在这篇文章中都解决了！耗费了偶很多的精力去猜测去思考！ 感觉一些已经得道的高人都不肯把这些问题说透彻点，唉，只能靠自己去摸索了，希望
WINDOWS SOCKET编程SELECT模型使用
u012252959的博客
09-19 540
int select(         int nfds,            //忽略         fd_ser* readfds,    //指向一个套接字集合，用来检测其可读性         fd_set* writefds,   // 指向一个套接字结合，用来检测其可写性         fd_ser* exceptfds, //指向一个套接字集合，用来检测
WindowSocket之异步IO----Select
chenweihua0088123456的博客
04-06 147
在accept、read、write等I/O操作的时候，如果没有符合条件的资源就一直等待下去，直到有资源为止。这就会造成堵塞，甚至使程序死掉；解决堵塞，可以使用异步I/O模型解决，下面列举5种，1) 选择模型(select)(主要用于服务端)2) 异步选择(WSAAsyncSelect)3) ...
windows socket网络编程二：select模型
c++小白的博客
01-04 2365
文章目录分析服务器定义一个装socket的结构select处理错误处理可写处理可读关闭服务器运行结果源码链接 分析 我们思考一下前面的程序有什么缺点？ 我们在调试程序的时候可以发现我们服务器在启动后，如果不打开客户端就一直卡着。 乍一看可能没什么问题，因为我们只有一个客户端，如果我们有多个客户端，由于accept、recv是傻等阻塞的，做其中一件事，另外一件事就做不了，在傻傻的等着，服务器完全无法正常工作。 解决方法： 我们可以给操作系统一组SOCKET，让系统帮我们监视着SOCKET的动向，哪个SOCKE
Windows控制台socket之Select模型聊天室
有人_295的博客
06-24 817
前言：不会QT和MFC，所以就在控制台实现socket之Select模型聊天室。 一、概述 程序使用到MySQL（很简单的运用）技术和Select编程模型，以MySQL数据库中关系辅以socket编程实现对目标好友或群组发送接收消息。可以同时允许多人（可以修改人数）对各自好友各自的群里进行愉快的通信。 1、 MySQL 主要提供用户之间的关系，供socket显示在线的用户，以及各自的群组。 2、 Socket主要实现消息处理 【1】服务端：用户U_ID和Socket关系的对应（为什么不是IP，因为IP会经常
socket select函数用法，图文并茂讲解，初学者必备
weixin_28673511的博客
04-08 1823
Linux IO多路复用三剑客之select，图文并茂简介select实现原理和用法，初学者必备。
win32环境下的Socket编程
weixin_34128411的博客
11-26 111
什么是Socket 　　Socket接口是TCP/IP网络的API，Socket接口定义了许多函数或例程，程序员可以用它们来开发 TCP/IP网络上的应用程序。要学Internet上的TCP/IP网络编程，必须理解Socket接口。 　　Socket接口设计者最先是将接口放在Unix操作系统里面的。如果了解Unix系统的输入和输出的话， 就很容易了解Socket了。网络的Socket数据传输是一种...
IOCP.rar_C++ iocp_DEMO_Gh0st_IOCP socket
09-20
CPIO socket demo src . c++
win-socket-demo_socket编程_socket_windows_DEMO_
10-03
windows
一个Win32 Socket的基于异步套接字多线程程序
12-02
这是一个基于Windows Socket网络编程的一个Win32控制台程序，通过使用异步模式实现服务器端和客户端的通信，服务器端注册套接字读事件，负责在套接字上接收数据，客户端注册发送事件，负责向服务器端发送数据，
A_IOCP_Class_IOCPNet_Demo.zip_DEMO_IOCP_IOCP class _iocpnet
09-23
一个很好的IOCP类，来自于codeproject 。http://www.codeproject.com/KB/IP/IOCPNet.aspx
IOCP.in.Csharp.rar_CSharp Socket_c# iocp_c#iocp_csharp iocp_csh
09-24
Windows IOCP Socket在C#封装，并有Socket池的实现
ioctlsocket.rar_IOCP_delphi iocp_ioctlsocket_socket ioctlsocket_
07-14
一个delphi中用多种模式socket的示例，包括： 1、阻塞单线程 2、阻塞多线程 3、非阻塞模式 4、Select模式 5、WSAAsynSelect模式 6、IOCP模式 7、UPD通讯 非常经典！
IOCP.rar_DEMO_IOCP_iocp delphi
09-14
与Delphi爱好者分享一个IOCP的代码实现演示源码，看了网上的例子做的一个Demo，common 目录为IOCP的代码，根目录下的是Demo代码。
网络安全与密码学
最新发布
weixin_61074128的博客
04-27 1339
一、密码学是一门研究信息安全保密的学科，主要涉及对信息进行加密、解密以及相关的安全技术和理论。它通过使用各种加密算法和技术，将明文信息转换为密文，以确保信息在传输和存储过程中的保密性、完整性和真实性。密码学在通信、电子商务、金融、军事等领域都有着广泛的应用。密码学包括对称加密、非对称加密、哈希函数、数字签名等重要内容。同时，密码学也在不断发展和创新，以应对不断变化的安全挑战。大家要注意的是我们平时用来认证身份的密码（passwd）翻译成口令更准确。
SD-WAN怎样保障网络稳定
TIANGEKUAJING的博客
04-25 586
随着企业网络的日益复杂，如何确保线路的稳定性和高效性成为了网络管理的一大挑战。尤其是在线路出现故障、质量下降或拥塞时，如何快速响应并切换到最佳线路，就显得尤为重要。SD-WAN，作为一种新型的网络架构，为用户提供了灵活应对各种网络问题的能力。
iocp udp c++demo
07-03
总结来说，IOC UDP C demo是一个使用IOCP和C语言实现的UDP通信示例程序，可以通过该示例了解IOCP的异步通信模型和C语言的编程技巧，以及UDP协议在网络通信中的应用。 ### 回答2： IOCP（Input/Output Completion ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值