5.linux_socket网络编程

最新推荐文章于 2023-08-14 02:50:22 发布
最新推荐文章于 2023-08-14 02:50:22 发布
阅读量418 收藏 1
点赞数
分类专栏： Linux 文章标签： linux
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_41682371/article/details/126980358
版权

目录

一、理论

二、编程实战

一、理论

1. 网络编程

前面学习的管道，消息队列，共享内存，信号，信号量，都依耐于linux内核，无法实现多机通讯，所以要学习网络编程，实现服务器和客户端之间的通讯。

地址：IP地址

           端口号：ftp服务/http服务/socket服务

数据：协议（http、tcp、udp）

socket套接字：tcp：面向连接，A打电话B，连接可靠，传指令

                        udp：面向报文，A发短信B，连接不可靠，视频，数据量大

tcp与udp对比：

tcp：面向连接，连接可靠，传指令，点到点，首部开销20个字节，全双工，可靠通信

udp：面向报文，连接不可靠，传视频，一对多、多对一、多对多，首付开销8个字节，不可靠通信

2. 字节序

字节序是指多个字节数据在计算机内存中存储或者网络传输时各字节的存储顺序。

小端字节序（little endian）：将低序字节存储在起始地址

大端字节序（big endian）：将高序字节存储在起始地址

3. socket是一种独立于协议的网络编程接口，即套接字，是一个抽象套，应用程序可以通过它发送或接收数据，可对其像文件一样打开，读写和关闭等操作，套接字允许应用程序将I/O插入到网络中，并与网络中的其他应用程序进行通信，网络套接字是IP地址与端口的组合，为了满足不同的通信程序，对通信质量和性能的要求，一般的网络系统提供了三种不同类型的套接字，以供用户在设计网络应用程序时，根据不同的要求来选择，为流式套接字、数据套接字、原始套接字。

socket接口是tcp/ip网络的api

二、编程实战

server.c

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>

int main(int argc , char **argv)
{

	//int socket(int domain, int type, int protocol);
	int s_fd;
	int c_fd;
	int n_read;
	char readBuf[128];

	char *msg = "I get your connect";
	struct sockaddr_in s_addr;
	struct sockaddr_in c_addr;

	memset(&s_addr,0,sizeof(struct sockaddr_in));	
	memset(&c_addr,0,sizeof(struct sockaddr_in));	

	//1. socket
	//s_fd = socket(AF_LOCAL,SOCK_STREAM,0);	
	s_fd = socket(AF_INET,SOCK_STREAM,0);	
	if(s_fd == -1){
		perror("socket");
		exit(-1);
	}

	s_addr.sin_family = AF_INET;
	s_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&s_addr.sin_addr);
	//inet_aton("127.0.0.1",&s_addr.sin_addr);

	//2. bind
	bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));

	//3. listen
	listen(s_fd,10);

	//4. accept
	int clen = sizeof(struct sockaddr_in);	
	while(1){	 

		c_fd = accept(s_fd, (struct sockaddr *)&c_addr, &clen);
		if(c_fd == -1){
			perror("accept");
		}
		//printf("contend");

		printf("get connect: %s\n", inet_ntoa(c_addr.sin_addr));

		if(fork() == 0){
			//5. read
			n_read = read(c_fd,readBuf,128);
			if(n_read == -1){
				perror("read");
			}else{
				printf("get message: %d,%s\n",n_read,readBuf);
			}
			//6. write
			write(c_fd,msg,strlen(msg));
			break;
		}
	}
	return 0;

}

client.c

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>

int main(int argc,char **argv)
{

	//int socket(int domain, int type, int protocol);
	int c_fd;
	int n_read;
	char readBuf[128];

	char *msg = "msg from client";
	struct sockaddr_in c_addr;
	
	memset(&c_addr,0,sizeof(struct sockaddr_in));	

	//1. socket
//	s_fd = socket(AF_LOCAL,SOCK_STREAM,0);	
	c_fd = socket(AF_INET,SOCK_STREAM,0);	
	if(c_fd == -1){
		perror("socket");
		exit(-1);
	}
	
	c_addr.sin_family = AF_INET;
	c_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&c_addr.sin_addr);
	//inet_aton("127.0.0.1",&s_addr.sin_addr);
	
	//2. connect
	if(connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr)) == -1 ){
		//perror("connect have cuo wu\n");
		perror("connect \n");
		exit(-1);
	}
	
	//printf("contend");
	
	printf("get connect: %s\n",inet_ntoa(c_addr.sin_addr));
	//3. send
	write(c_fd,msg,strlen(msg));
	
	//4. read
	n_read = read(c_fd,readBuf,128);
	if(n_read == -1){
		perror("read");
	}else{
		printf("get message from server: %d,%s\n",n_read,readBuf);
	}
	
	return 0;

}

CLC@Embed_Learn:~/socket$ gcc server.c -o server

CLC@Embed_Learn:~/socket$ gcc client.c -o client
 

CLC@Embed_Learn:~/socket$ ./server 127.0.0.1 8888
get connect: 127.0.0.1
get message: 15,msg from client
get connect: 127.0.0.1
get message: 15,msg from client

......没有退出
 

CLC@Embed_Learn:~/socket$ ./client 127.0.0.1 8888
get connect: 127.0.0.1
get message from server: 18,I get your connect
CLC@Embed_Learn:~/socket$ ./client 127.0.0.1 8888
get connect: 127.0.0.1
get message from server: 18,I get your connect
CLC@Embed_Learn:~/socket$   退出

服务端，在bind()函数中设置好IP号和端口号，先使用监听listen()函数，在使用连接accept()函数，read()函数读客户端的数据，并显示出来，write()函数给客户端返回一个指令状态。服务端不会退出，有一个while()函数，还使用fork()函数，客户端一运行服务端就起来了。

客户端，先使用write()函数，后使用read()函数，与服务端的read和write刚好一一对应起来。我写你读，我读你写。

双方可以实现通信

server1.c

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>

int main(int argc , char **argv)
{

	//int socket(int domain, int type, int protocol);
	int s_fd;
	int c_fd;
	int n_read;
	char readBuf[128];

	char msg[128] = {0};
	//	char *msg = "I get your connect";
	struct sockaddr_in s_addr;
	struct sockaddr_in c_addr;

	if(argc != 3){
		printf("param is not good\n");
		exit(-1);
	}

	memset(&s_addr,0,sizeof(struct sockaddr_in));	
	memset(&c_addr,0,sizeof(struct sockaddr_in));	

	//1. socket
	//	s_fd = socket(AF_LOCAL,SOCK_STREAM,0);	
	s_fd = socket(AF_INET,SOCK_STREAM,0);	
	if(s_fd == -1){
		perror("socket");
		exit(-1);
	}

	s_addr.sin_family = AF_INET;
	s_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&s_addr.sin_addr);
	//inet_aton("127.0.0.1",&s_addr.sin_addr);

	//2. bind
	bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));

	//3. listen
	listen(s_fd,10);

	//4. accept
	int clen = sizeof(struct sockaddr_in);	
	while(1){	 

		c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&clen);
		if(c_fd == -1){
			perror("accept");
		}
		//printf("contend");

		printf("get connect: %s\n",inet_ntoa(c_addr.sin_addr));

//数据有到来时，创建一个上面的子进程去操作，子进程同时执行两个while(1),按照以前的经验，想要执行两个while(1),要么用线程，要么创建一个下面的子进程，
//两个while(1)同时跑，上面的子进程对接的是一个客户端，它既能不断的来检测，往套接字上面发送数据，也能读取套接字上面的数据。
		if(fork() == 0){

			if(fork() == 0){
				while(1){
					memset(msg,0,sizeof(msg));
					printf("input: ");
					gets(msg);
					//6. write
					write(c_fd,msg,strlen(msg));
				}
			}
			while(1){
				memset(readBuf,0,sizeof(readBuf));
				//5. read
				n_read = read(c_fd,readBuf,128);
				if(n_read == -1){
					perror("read");
				}else{
					printf("get message: %d,%s\n",n_read,readBuf);
				}
			}
			break;
		}
	}
	return 0;

}

 client1.c

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>

int main(int argc,char **argv)
{

	//int socket(int domain, int type, int protocol);
	int c_fd;
	int n_read;
	char readBuf[128];

	//	char *msg = "msg from client";
	char msg[128] = {0};
	struct sockaddr_in c_addr;

	memset(&c_addr,0,sizeof(struct sockaddr_in));	

	if(argc != 3){
		printf("param is not good\n");
		exit(-1);
	}

	//1. socket
	//	s_fd = socket(AF_LOCAL,SOCK_STREAM,0);	
	c_fd = socket(AF_INET,SOCK_STREAM,0);	
	if(c_fd == -1){
		perror("socket");
		exit(-1);
	}

	c_addr.sin_family = AF_INET;
	c_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&c_addr.sin_addr);
	//inet_aton("127.0.0.1",&s_addr.sin_addr);

	//2. connect
	if(connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr)) == -1 ){
		//perror("connect have cuo wu\n");
		perror("connect \n");
		exit(-1);
	}
	while(1){//客户端：while(1)中要执行两个while(1)，要么用线程，要么用创建一个子进程，这么创建了一个子进程来完成这个操作
		if(fork() == 0){
			while(1){
				memset(msg,0,sizeof(msg));
				printf("input: ");
				gets(msg);
				//write
				write(c_fd,msg,strlen(msg));
			}
		}
		while(1){
			memset(readBuf,0,sizeof(readBuf));
			//4. read
			n_read = read(c_fd,readBuf,128);
			if(n_read == -1){
				perror("read");
			}else{
				printf("get message from server: %d,%s\n",n_read,readBuf);
			}
		}
	}

	//printf("contend");

	//printf("get connect: %s\n",inet_ntoa(c_addr.sin_addr));
	//3. send
	write(c_fd,msg,strlen(msg));

	return 0;
}

CLC@Embed_Learn:~/socket$ gcc server1.c -o server1
CLC@Embed_Learn:~/socket$ gc client1.c -o client1
 

CLC@Embed_Learn:~/socket$ ./server1 127.0.0.1 8888
get connect: 127.0.0.1
input: get message: 12,nihao client
nihao server
input: hello server
input: get message: 12,hello client 

CLC@Embed_Learn:~/socket$ ./client1 127.0.0.1 8888
input: nihao,client
input: get message from server: 12,nihao,server
get message from server: 12,hello server
hello client

可以实现双方互相聊天，那么可以实现多人聊天吗？请看server2.c

 server2.c

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>

int main(int argc , char **argv)
{

	//int socket(int domain, int type, int protocol);
	int s_fd;
	int c_fd;
	int n_read;
	char readBuf[128];
	
	int mark = 0;
	char msg[128] = {0};
	//	char *msg = "I get your connect";
	struct sockaddr_in s_addr;
	struct sockaddr_in c_addr;

	if(argc != 3){
		printf("param is not good\n");
		exit(-1);
	}

	memset(&s_addr,0,sizeof(struct sockaddr_in));	
	memset(&c_addr,0,sizeof(struct sockaddr_in));	

	//1. socket
	//	s_fd = socket(AF_LOCAL,SOCK_STREAM,0);	
	s_fd = socket(AF_INET,SOCK_STREAM,0);	
	if(s_fd == -1){
		perror("socket");
		exit(-1);
	}

	s_addr.sin_family = AF_INET;
	s_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&s_addr.sin_addr);
	//inet_aton("127.0.0.1",&s_addr.sin_addr);

	//2. bind
	bind(s_fd,(struct sockaddr *)&s_addr,sizeof(struct sockaddr_in));

	//3. listen
	listen(s_fd,10);

	//4. accept
	int clen = sizeof(struct sockaddr_in);	
	while(1){	 

		c_fd = accept(s_fd,(struct sockaddr *)&c_addr,&clen);
		if(c_fd == -1){
			perror("accept");
		}
		//printf("contend");

		mark++;

		printf("get connect: %s\n",inet_ntoa(c_addr.sin_addr));

		if(fork() == 0){

			if(fork() == 0){
				while(1){
					sprintf(msg,"welcom No.%d client",mark);
					//6. write
					write(c_fd,msg,strlen(msg));
					sleep(3);
				}
			}
			while(1){
				memset(readBuf,0,sizeof(readBuf));
				//5. read
				n_read = read(c_fd,readBuf,128);
				if(n_read == -1){
					perror("read");
				}else{
					printf("get message: %d,%s\n",n_read,readBuf);
				}
			}
			break;
		}
	}
	return 0;
}

client1.c

#include <stdio.h>
#include <sys/types.h>          /* See NOTES */
#include <sys/socket.h>
//#include <linux/in.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>

int main(int argc,char **argv)
{

	//int socket(int domain, int type, int protocol);
	int c_fd;
	int n_read;
	char readBuf[128];

	//	char *msg = "msg from client";
	char msg[128] = {0};
	struct sockaddr_in c_addr;

	memset(&c_addr,0,sizeof(struct sockaddr_in));	

	if(argc != 3){
		printf("param is not good\n");
		exit(-1);
	}

	//1. socket
	//	s_fd = socket(AF_LOCAL,SOCK_STREAM,0);	
	c_fd = socket(AF_INET,SOCK_STREAM,0);	
	if(c_fd == -1){
		perror("socket");
		exit(-1);
	}

	c_addr.sin_family = AF_INET;
	c_addr.sin_port = htons(atoi(argv[2]));
	inet_aton(argv[1],&c_addr.sin_addr);
	//inet_aton("127.0.0.1",&s_addr.sin_addr);

	//2. connect
	if(connect(c_fd,(struct sockaddr *)&c_addr,sizeof(struct sockaddr)) == -1 ){
		//perror("connect have cuo wu\n");
		perror("connect \n");
		exit(-1);
	}
	while(1){//客户端：while(1)中要执行两个while(1)，要么用线程，要么用创建一个子进程，这么创建了一个子进程来完成这个操作
		if(fork() == 0){
			while(1){
				memset(msg,0,sizeof(msg));
				printf("input: ");
				gets(msg);
				//write
				write(c_fd,msg,strlen(msg));
			}
		}
		while(1){
			memset(readBuf,0,sizeof(readBuf));
			//4. read
			n_read = read(c_fd,readBuf,128);
			if(n_read == -1){
				perror("read");
			}else{
				printf("get message from server: %d,%s\n",n_read,readBuf);
			}
		}
	}

	//printf("contend");

	//printf("get connect: %s\n",inet_ntoa(c_addr.sin_addr));
	//3. send
	write(c_fd,msg,strlen(msg));

	return 0;
}

CLC@Embed_Learn:~/socket$ gcc server2.c -o server2
CLC@Embed_Learn:~/socket$ gcc client1.c -o client1


CLC@Embed_Learn:~/socket$ ./server2 127.0.0.1 8877
get connect: 127.0.0.1
get message: 5,nihao 
get connect: 127.0.0.1

CLC@Embed_Learn:~/socket$ ./client1 127.0.0.1 8877
input: get message from server: 18,welcom No.1 client
get message from server: 18,welcom No.1 client
get message from server: 18,welcom No.1 client
nihao get message from server: 18,welcom No.1 client

input: get message from server: 18,welcom No.1 client
get message from server: 18,welcom No.1 client
get message from server: 18,welcom No.1 client

......


CLC@Embed_Learn:~/socket$ ./client1 127.0.0.1 8877
input: get message from server: 18,welcom No.2 client
get message from server: 18,welcom No.2 client
get message from server: 18,welcom No.2 client
......

1  可以多人聊天，但存在竞争关系

2  存在资源竞争，所以服务器发送的消息，不能同时给两个客户端发过去，现在让服务端自动给客户端回复消息。
    如果我们不获取键盘的输入，每一个客户端发数据上来，自动的回复，客户端就知道连接有没有丢失。服务端都可以收到客户端的请求。

 

 

代码_钢琴家
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
socket网络编程（源代码）
05-25
socket网络编程（源代码） 所谓socket通常也称作"套接字"，应用程序通常通过"套接字"向网络发出请求或者应答网络请求。
Socket网络编程实例代码
07-11
用C#语言写Socket，实现TCP客户端和服务器通讯，实现收发消息等功能。
socket网络编程
最新发布
weixin_51972895的博客
08-14 295
socket完整服务端实现：能够实现客户端接入，并且能够读取客户端信息，给客户端返回消息。
Linux系统编程—网络编程—socket代码实现
L132455的博客
05-07 290
socket代码实现 一、服务端步骤： 1.socket #include <sys/types.h> /* See NOTES */ #include <sys/socket.h> int socket(int domain, int type, int protocol); 第一个参数domain设置为“AF_INET”。 第二个参数是套接口的类型：SOCK_STREAM或 SOCK_DGRAM。第三个参数设置为0。
1.socket网络编程
weixin_42636062的博客
08-28 1131
socket网络编程总结（Linux+Windows） 理解为：套接字通信，网络通信 1.概念 1.1 局域网和广域网 局域网：局域网将一定区域内的各种计算机、外部设备和数据库连接起来形成计算机通信的私有网络。 广域网：又称广域网、外网、公网。是连接不同地区局域网或城域网计算机通信的远程公共网络。 1.2 IP（Internet Protocol） 本质是一个整形数，用于表示计算机在网络中的地址。IP 协议版本有两个：IPv4 和 IPv6 1.2.1 IPv4（Internet Protocol vers
ss.rar_linux socket编程_socket编程
09-19
Linux Socket编程是网络编程的重要组成部分，它为进程间通信提供了基于网络的数据传输接口。本教程主要围绕"ss.rar"中的"ss.cpp"源代码文件，介绍Linux系统下的Socket编程基础知识和一个服务端示例，旨在帮助初学者...
Linux_下的Socket编程.zip_Linux_下的Socket编程_socket编程
09-20
最后，文档中的"Linux_下的Socket编程.doc"可能会涵盖以上所述的各个知识点，并可能提供示例代码，帮助读者更好地理解和应用Socket编程。实践中，通过编写简单的客户端和服务器程序，可以加深对Socket编程的理解。...
linux-socket-c.rar_linux socket tcp_linux 网络编程_linux网络编程_socket
09-21
在Linux系统中，Socket编程是实现网络通信的核心技术，它为开发者提供了标准接口，使得程序可以与网络服务进行数据交互。TCP（Transmission Control Protocol）和UDP（User Datagram Protocol）是两种主要的传输层...
sc.rar_linux socket 例子_linux socket编程
09-22
在Linux系统中，Socket编程是网络编程的基础，它允许程序通过网络进行通信。"sc.rar_linux socket 例子_linux socket编程" 提供了一个客户端的示例，对于初学者来说，这是一个非常有价值的资源，可以帮助理解如何在...
Socket.rar_网络编程_Unix_Linux_
08-12
Socket编程是计算机科学中一种重要的通信机制，尤其在Unix和Linux操作系统中，它被广泛用于构建网络应用程序。本文将深入探讨Socket编程的概念、原理以及如何使用C++进行实践。 Socket，通常被称为套接字，是进程间...
socket网络编程--有详细的描述及源代码演示
12-27
网络编程，如此轻松学习OK！错过这个村，就没这个店了。哈哈
socket 一个服务器对应多个客户端使用多线程
04-27
多线程实现的一对多编程，使用Linux下的socket进行编程。
linux socket循环连接测试代码。
qq_42074368的博客
10-14 426
提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录一、linux socket 学习和编写？二、直接上代码三、效果图示 一、linux socket 学习和编写？ 主要目的是使用vs 调试linux socket程序（直接linux上可以运行）。服务器端循环接收客户端消息，发送消息给客户端，客户端同样发送和接收消息。循环建立连接。 使用vs 调试linux程序，具体可以参考 linux c程序编写工具（使用visual studio) 二、直接上代码 /* 服务器端 */ #i
【Linux】一文搞懂socket网络编程！！！附详细代码
w903414的博客
12-21 1868
tcp网络编程，udp网络编程，附详细代码。
Linux下socket网络编程
qq_52914199的博客
02-22 364
socket网络编程主要分别为tcp和udp。他们的主要区别是tcp是连接式，传输数据无丢失、无差错、无重复。udp是无连接式，工作效率比tcp高，适用于对高速传输和实时性有较高的通信或广播通信。tcp服务器端工作流程：（1）使用socket()函数创建socket对象。（2）使用bind()函数把创建的socket句柄绑定到指定的TCP端口。（3）调用listen()函数使socket处于监听状态，并且设置监听队列的大小。
Linux环境下的基于C++的一对多 Socket 通信
weixin_41951718的博客
09-07 510
server： #include<stdio.h> #include<stdlib.h> #include<string.h> #include<sys/socket.h> #include<netinet/in.h> #include<arpa/inet.h> #include<unistd.h> #include<signal.h> int sockfd; void fa(int signo) {
（完善之后的程序）linuxTCP一对多通信
angel的博客
06-05 781
服务端： #include &lt;unistd.h&gt; #include &lt;stdio.h&gt; #include &lt;sys/socket.h&gt; #include &lt;stdlib.h&gt; #include &lt;signal.h&gt; #include &lt;pthread.h&gt; #include &lt;string.h&gt; #inclu
糖儿飞教你学C++ Socket网络编程——24. 控制台版多线程TCP一对多通信程序
03-09 957
本节实现一个多线程TCP通信程序，该程序与项目二的程序相比，最大的特点就是可以实现一对多通信，即一个服务器端可以与若干个客户端同时通信，一个服务器端与3个相同的客户端同时通信的运行效果如图10-1所示。 图10-1 多线程TCP通信程序的界面（左上为服务器端，其余均为客户端） 10.2.1服务器端程序的原理 在TCP通信中，要使服务器端能够同时接受多个客户端的连接，则可以把accept(...
用C++实现简单的一对多Socket通讯（二）
立于浮华之世，奏出天使之章
03-10 2615
回顾 上一篇文章实现了一个最简单的socket连接，但只能进行一对一通讯，所以本篇文章将会将功能扩展下，实现一对多的通讯方式。上篇实现代码中，感谢@rf_versace指出服务器接受数据的容器太小，容易溢出，这点之前没有想到过，目前解决的方法就是设置大一点，一般来说消息都会有序列化和反序列化，关于序列化和反序列化之后再写一篇文章来说下。 一个多线程服务器 和上一篇文章一样，我们初始化sock...
Linux网络编程：socket接口详解
"Linux网络编程中的socket函数" 在Linux操作系统中，网络编程主要依赖于socket接口。这个接口提供了进程间通信的能力，不仅限于同一台计算机内的进程，还允许跨网络的进程之间进行通信。socket是一种特殊的I/O接口...

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值