网络编程_3(TCP)

最新推荐文章于 2025-08-13 07:38:11 发布
原创 最新推荐文章于 2025-08-13 07:38:11 发布 · 241 阅读 · 1 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#网络

该博客聚焦于TCP相关内容，介绍了TCP模型，包含listen、accept等操作。还阐述了服务器模型，循环服务器一次只能处理一个客户端，有不能处理耗时操作的缺点；并发服务器可同时处理多客户端请求，分为多进程和多线程并发服务器，并给出了代码实现。

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

五、TCP

一二章请前往：网络编程_1（网络基础+跨主机传输
三四章请前往：网络编程_2(网络属性+UDP(UDP模型+广播组播))

（一）TCP模型

1.TCP模型

在这里插入图片描述

2.listen

功能：监听套接字;
头文件：
       #include <sys/types.h>          /* See NOTES */
       #include <sys/socket.h>
原型：
       int listen(int sockfd, int backlog);
参数：
    int sockfd：用socket函数生成的流式套接字.要被转换成监听套接字的套接字。
    int backlog：允许建立多少链接。
    		内核会为每一个socket套接字维护两个队列.
    		未完成连接的队列。/proc/sys/net/ipv4/tcp_max_syn_backlogc
    		以完成连接的队列，等着accept函数拿走;
返回值：
    成功，返回0;
	失败，返回-1;

3.accept（阻塞函数）

功能：接收客户端的链接，并返回套接字;从已完成链接的队列头中，取出一个链接。（文件描述符）;
头文件：
       #include <sys/types.h>          /* See NOTES */
       #include <sys/socket.h>
原型：
       int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
参数：
    int sockfd：已经被listen监听的套接字；
    struct sockaddr *addr：存储链接成功的客户端的信息：ip和端口。
           struct sockaddr_in {
               sa_family_t    sin_family; /* address family: AF_INET */
               in_port_t      sin_port;   /* port in network byte order */
               struct in_addr sin_addr;   /* internet address */
           };
           /* Internet address. */
           struct in_addr {
               uint32_t       s_addr;     /* address in network byte order */
           };
	socklen_t *addrlen：第二个结构体的大小，就是sizeof(struct sockaddr_in);
参数：
    成功，返回一个新的套接字，是与客户端建立链接的套接字;
		往这个套接字中读写消息，就是与客户端通讯;
	失败，返回-1，更新errno。

4.recv

功能：从套接字中获取数据;
头文件:
       #include <sys/types.h>
       #include <sys/socket.h>
原型：
       ssize_t recv(int sockfd, void *buf, size_t len, int flags);
       ssize_t read(int fd, void *buf, size_t count);
参数：
    int sockfd：从该文件描述符中读取数据; accept函数返回的新的套接字;
	void *buf：存储获取到的数据;
	size_t len：指定要接受的数据大小;
	int flags：接收方式：0，默认方式接收。阻塞;
返回值：
    > 0；接收的字符个数;
	=0; 对方关闭，对方调用close关闭文件描述符;
	=-1；函数调用出错.     
     errno = EINTR  The receive was interrupted by delivery of a signal before any data werec available;
	需要忽略犹豫信号干扰造成的数据传输中断。

5.send

功能：发送数据到套接字中;
头文件：
       #include <sys/types.h>
       #include <sys/socket.h>
原型：
       ssize_t send(int sockfd, const void *buf, size_t len, int flags);
       ssize_t write(int fd, const void *buf, size_t count);
参数：
    int sockfd：套接字;
	void *buf：需要发送的数据;
	size_t len：需要发送的数据大小;
	int flags：发送方式：0，默认方式发送。阻塞;
返回值：
    成功，返回发送成功的数据个数;
	失败，返回-1，更新errno;
	errno = EINTR  The receive was interrupted by delivery of a signal before any data were available;
	需要忽略犹豫信号干扰造成的数据传输中断。

6.connect

功能：连接服务器;
头文件：
       #include <sys/types.h>          /* See NOTES */
       #include <sys/socket.h>
原型：
       int connect(int sockfd, const struct sockaddr *addr,  socklen_t addrlen);
参数：
    int sockfd：套接字;
	struct sockaddr *addr：通用结构体，iPv4的结构体，填充服务器的地址信息和端口;
	socklen_t addrlen：第二个结构体的大小;
返回值：
    成功，返回0;
	失败，返回-1，跟新errno;

7.shutdown

#include <sys/socket.h>
int shutdown(int sockfd,int how)
参数：
    SHUT_RD关闭读端，无法从套接字种读取数据
    SHUT_WR关闭写端，无法使用套接字发送数据
    SHUT_RDWR关闭读写端,则无法读写
返回值：
    成功返回0
    失败返回-1，设置errno

（二）服务器模型

1.循环服务器

1）一次只能处理一个客户端，等这个客户端退出后，才能处理下一个客户端。
2）缺点循环服务器所处理的客户端不能有耗时操作

socket();
bind();
listen();
while(1){
    newfd = accept();
    while(1){
        recv();
        fun`````
    }
    close();
}
close();

例子

服务器
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
int main(int argc, const char *argv[])
{
    //1.创建套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sfd < 0)
    {
        perror("socket");
        return -1;
    }
    //允许本地端口快速重用
    int reuse = 1;
    setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(int));
    //2.绑定
    //填充服务器信息
    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_port = htons(2020);
    sin.sin_addr.s_addr = inet_addr("0");
    if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin))<0)
    {
        perror("bind");
        exit(1);
    }
    printf("绑定成功\n");
    //3.监听
    if(listen(sfd, 3)<0)
    {
        perror("listen");
        exit(1);
    }
    //4.接收客户端的连接
    struct sockaddr_in cin;
    socklen_t len = sizeof(cin);
    int cntfd = -1;
    while(1)
    {
        cntfd = accept(sfd, (void*)&cin, &len);
        if(cntfd < 0)
        {
            perror("accept");
            exit(1);
        }
        printf("客户端链接成功 %d\n", cntfd);
        char ip[20] = "";
        inet_ntop(AF_INET, &cin.sin_addr, ip, 20);
        printf("[%s:%d]连接成功\n", ip, ntohs(cin.sin_port));
        int ret = -1;
        while(1)
        {
            //5.recv接收数据
            char buf[256] = "";
            bzero(buf, sizeof(buf));
            do
            {
                ret= recv(cntfd, buf, 256, 0);
            }while(ret<0 && errno == EINTR);
            if(ret < 0)
            {
                perror("recv");
                exit(1);
            }
            else if(0 == ret)
            {
                fprintf(stderr, "对方关闭\n");
                break;
            }
            printf("%s\n", buf);
        }
        close(cntfd);
    }
    close(sfd);c
    return 0;
}
客户端
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
int main(int argc, const char *argv[])
{
    //1.创建套接字
    int fd = socket(AF_INET, SOCK_STREAM, 0);
    if(fd < 0)
    {
        perror("socket");
        return -1;
    }
    //允许本地端口快速重用
    int reuse = 1;
    int len = sizeof(reuse);
    if(setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &reuse, len)<0)
    {
        perror("setsockopt");
        exit(1);
    }
    //2.绑定 非必须
    //3.连接服务器
    //填充服务器信息
    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_port = htons(2020);
    sin.sin_addr.s_addr = inet_addr("192.168.1.141");
    //int connect(int sockfd, \
    //const struct sockaddr *addr,  socklen_t addrlen);
    if(connect(fd, (void*)&sin, sizeof(sin))<0)
    {
        perror("connect");
        exit(1);
    }
    printf("连接成功\n");
    char buf[256] = "";
    //4.发送消息
    int ret = -1;
    while(1)
    {
        bzero(buf, sizeof(buf));
        fprintf(stderr, "请输入：");
        fgets(buf, 256-1, stdin);
        // ssize_t send(int sockfd, const void *buf, size_t len, int flags);
        do
        {
            ret = send(fd, buf, strlen(buf), 0);
        }while(ret<0 && errno == EINTR);
        if(ret < 0)
        {
            perror("send");
            exit(1);
        }
    }
    close(fd);                                                                         
    return 0;
}

2.并发服务器

1）可以同时处理多个客户端请求，创建子进程或者线程来处理客户端的请求
2）父进程/主线程只负责连接，子进程/分支线程 只负责与客户端进行交互。

1.多进程并发服务器
void handler(int signo) {
    waitpid()
}
sockfd = socket();
bind();
listen();
signal(SIGCHLD,handler);
while(1){
    confd=accpet(); 
    /*******子进程*******/
    if(fork()==0){
        close(sockfd);
        while(1){
            recv();
            fun------;c
        }
        exit(1);
    }
    /*******父进程*******/
    close(confd);
}
close(scokfd);
代码实现
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
void show_info(struct sockaddr_in cin);
void recv_cli_msg(int newfd, struct sockaddr_in cin);
void handler(int sig)
{
    //信号处理函数中不能有耗时操作
    if (signo == SIGCHLD) {
    while(waitpid(-1,NULL,WNOHANG) > 0);
  //循环回收多个子进程，
  //当waitpid非阻塞成功回收子进程后，
  //继续尝试回收一次，如果回收成功，继续尝试回收
  //如果回收失败，说明没有僵尸进程需要回收了
}
int main(int argc, const char *argv[])
{
    //捕获信号
    if(signal(SIGCHLD, handler) == SIG_ERR)
    {
        perror("signal");
        return -1;
    }
    //1.创建套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sfd < 0)
    {
        perror("socket");
        return -1;
    }
    //允许本地端口快速重用
    int reuse = 1;
    setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(int));
    //2.绑定
    //填充服务器信息
    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_port = htons(2020);
    sin.sin_addr.s_addr = inet_addr("0");
    if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin))<0)
    {
        perror("bind");
        exit(1);
    }
    printf("绑定成功\n");
    //3.监听
    if(listen(sfd, 3)<0)
    {
        perror("listen");
        exit(1);
    }
    //4.接收客户端的连接
    struct sockaddr_in cin;
    socklen_t len = sizeof(cin);
    int cntfd = -1;
    while(1)
    {
        cntfd = accept(sfd, (void*)&cin, &len);
        if(cntfd < 0)
        {
            perror("accept");
            exit(1);
        }
        printf("客户端链接成功 %d\n", cntfd);
        show_info(cin);
        int ret = -1;
        pid_t pid = fork();
        if(0 == pid)
        {          
            //子进程 与客户端进行数据交互;
            close(sfd);
            recv_cli_msg(cntfd, cin);
            close(cntfd);
            exit(1);
        }
        else if(pid > 0)
        {
            //父进程直接返回。
            close(cntfd);
        }
        else
        {
            perror("fork");
            close(cntfd);
        }
    }
    close(sfd);
    return 0;
}
void show_info(struct sockaddr_in cin)
{
    char ip[20] = "";
    inet_ntop(AF_INET, &cin.sin_addr, ip, 20);
    printf("[%s:%d]连接成功\n", ip, ntohs(cin.sin_port));
}
void recv_cli_msg(int newfd, struct sockaddr_in cin)
{
    char buf[256] = "";
    int ret = -1;
    char ip[20] = "";
    inet_ntop(AF_INET, &cin.sin_addr, ip, 20);
    int port = ntohs(cin.sin_port);
    while(1)
    {
        bzero(buf, sizeof(buf));
        //接收数据
        do
        {
            ret = recv(newfd, buf, 256, 0);
        }while(ret < 0 && EINTR == errno);
        if(ret < 0)
        {
            perror("recv");
            return;
        }
        else if(0 == ret)
        {
            fprintf(stderr, "[%s:%d] 客户端断开连接\n",ip, port);
            return;
        }
        printf("[%s:%d]:%s\n", ip, port, buf);
    }
}
2.多线程并发服务器
sockfd = socket();
bind();
listen();
while(1){
    confd=accpet(); 
    /****子线程********/c
	pthread_create() --> func接收消息
    /****子线程********/
    pthrad_detach()
}
close(scokfd);
代码实现
#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/ip.h>
#include <arpa/inet.h>
#include <stdlib.h>
#include <string.h>
#include <errno.h>
#include <signal.h>
#include <pthread.h>
typedef struct
{
    int newfd;
    struct sockaddr_in cin;
}__cli_info;
void show_info(struct sockaddr_in cin);
void* recv_cli_msg(void* arg);
int main(int argc, const char *argv[])
{
    //1.创建套接字
    int sfd = socket(AF_INET, SOCK_STREAM, 0);
    if(sfd < 0)
    {
        perror("socket");
        return -1;
    }
    //允许本地端口快速重用
    int reuse = 1;
    setsockopt(sfd, SOL_SOCKET, SO_REUSEADDR, &reuse, sizeof(int));
    //2.绑定
    //填充服务器信息
    struct sockaddr_in sin;
    sin.sin_family = AF_INET;
    sin.sin_port = htons(2020);
    sin.sin_addr.s_addr = inet_addr("0");
    if(bind(sfd, (struct sockaddr*)&sin, sizeof(sin))<0)
    {
        perror("bind");
        exit(1);
    }
    printf("绑定成功\n");
    //3.监听
    if(listen(sfd, 3)<0)
    {
        perror("listen");
        exit(1);
    }
    printf("服务器启动成功\n");
    //4.接收客户端的连接
    struct sockaddr_in cin;
    socklen_t len = sizeof(cin);
    int cntfd = -1;
    while(1)
    {
        cntfd = accept(sfd, (void*)&cin, &len);
        if(cntfd < 0)
        {
            perror("accept");
            exit(1);
        }
        printf("客户端链接成功 %d\n", cntfd);
        show_info(cin);
        int ret = -1;
        //创建一个线程
        __cli_info cliInfo;
        cliInfo.newfd = cntfd;
        cliInfo.cin = cin;
        //有一个客户端一旦连接成功，就创建一个线程，作为与客户到交互的线程。
        pthread_t tid = -1;
        if(pthread_create(&tid, NULL, recv_cli_msg, (void*)&cliInfo) < 0)
        {
            perror("pthread_create");
            close(cntfd);
        }
    }
    close(sfd);
    return 0;
}
void show_info(struct sockaddr_in cin)
{
    char ip[20] = "";
    inet_ntop(AF_INET, &cin.sin_addr, ip, 20);
    printf("[%s:%d]连接成功\n", ip, ntohs(cin.sin_port));
}
void* recv_cli_msg(void* arg)
{
    //分离线程，线程退出后自动回收资源;
    pthread_detach(pthread_self());
    __cli_info cli = *(__cli_info*)arg;
    int newfd = cli.newfd;
    struct sockaddr_in cin = cli.cin;
    char ip[20] = "";
    inet_ntop(AF_INET, &cin.sin_addr, ip, 20);
    int port = ntohs(cin.sin_port);
    char buf[256] = "";
    int ret = -1;
    while(1)
    {
        bzero(buf, sizeof(buf));
        //接收数据
        do
        {
            ret = recv(newfd, buf, 256, 0);
        }while(ret < 0 && EINTR == errno);
        if(ret < 0)
        {
            perror("recv");
            break;
        }
        else if(0 == ret)
        {
            fprintf(stderr, "[%s:%d]断开连接\n", ip, port);
            break;
        }
        printf("[%s:%d]:%s\n", ip,port, buf);
    }
    close(newfd);
    pthread_exit(NULL);
}
°嘟嘟嘟嘟
关注
std::thread初始化（1）--普通函数
鸟哥的博客
08-22 934
#include <iostream> #include <utility> #include <thread> #include <chrono> void f1(int n) { std::cout << "function f1\n"; ++n; } void f2(int& n) { std::cout << "function
基于TCP的通信程序设计（C语言）
07-13
　答辩通过后，进一步修改的，没有问题。若有疑问请联系我　　 　1. 服务器端功能：接收客户连接请求，建立连接，显示客户IP地址和端口号，接收并显示客户发送的信息，并向该客户发送“I am a server. ”的信息。 　2. 客户端功能：向服务器提出TCP请求，当连接建立后，向服务器发送“I am a client.”的信息，接收并显示从服务器收到的信息，并断开服务器的连接。
实现TCP网络编程例题3
LeungKiChen
10-26 145
实现TCP网络编程例题3 package com.atguigu.java1; import org.junit.Test; import java.io.*; import java.net.InetAddress; import java.net.ServerSocket; import java.net.Socket; /** * 实现TCP网络编程例题3 * 从客户端发送文件给服务端，服务端保存到本地。并返回“发送成功”给客户端。 * 并关闭相应的连接 * @author li.
C++中的并发线程(一)
Awesomewan的博客
09-20 490
C++中的并发线程初接触 当我想要用另一个线程实现hello world函数时 mian.c函数 #include <iostream> #include <thread> using namespace std; void hello() { cout<<"hello concurrent world\n"; } int main() { thread t(hello); cout<<"hello world"<<end
解决在linux环境下的clion 运行不了thread的问题
cainiaocl的博客
02-19 1684
问题 我们在linux下使用clion编程时，遇到这种情况 [ 50%] Linking CXX executable Study_C_project CMakeFiles/Study_C_project.dir/main.cpp.o: In function std::thread::thread<void (&)(int), int>(void (&)(int),...
C++11/std::thread - 可作为线程函数的几种方式总结
HW140701的博客
04-01 3398
1 使用普通的函数作为线程函数 代码示例： #include <iostream> #include <thread> void ThreadFunction() { std::cout<< "线程函数被启动" << std::endl; } int main() { std::thread thread(ThreadFunct...
tcp.rar_CVI 网络_CVI的TCP编程_LabWindows TCP/IP _cvi 网络编程_labwindows
09-20
在IT行业中，网络编程是构建分布式系统和网络应用的基础，而TCP（传输控制协议）作为互联网协议栈中的重要组成部分，负责可靠的数据传输。本资源"tcp.rar"提供了一个基于LabWindows/CVI的TCP/IP网络编程实例，对于...
linux-TCP.rar_LINUX TCP _Linux 网络 编程_linux c_linux tcp传输_tcp lin
09-23
标题中的“Linux TCP”指的是在Linux操作系统环境下进行TCP（Transmission Control Protocol）网络编程。TCP是互联网协议栈中的一种面向连接的、可靠的、基于字节流的传输层通信协议。在这个主题下，我们主要探讨...
tcp.rar_Windows编程_tcp_tcp windows_tcp 服务器_windows tcp
09-23
在Windows平台上进行网络编程，TCP（Transmission Control Protocol）是一种常用且至关重要的协议，它提供了可靠的、基于连接的数据传输服务。本资源"tcp.rar"包含了Windows环境下编写TCP服务器和客户端程序的相关...
CSharp_TCP_UDP.rar_CSharp-TCP/UDP_TCP/UDP编程_TCP/UDP编程C_c# tcp库_c
07-13
丰富的C#网络编程知识,TCPUPD等网络协议相关编程以及文件的传输以及下载功能
C++ 多线程(3)std::thread 详解
热门推荐
一抹烟霞的博客
05-30 1万+
文章目录一、头文件二、std::thread 构造函数三、其他成员函数四、传递临时参数作为线程对象的注意事项4.1 **解决办法：**4.2 原因分析4.3 总结五、传递类对象、智能指针作为线程参数5.1 修改子线程中的对象，不会影响主线程中的对象5.2 传递智能指针参考链接： 一、头文件 std::thread 在 头文件中声明，因此使用 std::thread 时需要包含 头文件。 二、std::thread 构造函数 (1). 默认构造函数，创建一个空的 thread 执行对象。 (2). 初始
在linux下用vscode结合CMake来编译含有多线程库的源文件时要注意的问题
weixin_44980842的博客
12-18 2030
当我们在linux下用vscode进行多线程编程的时候，我们会用到<thread>这个包下的类和函数，但是如果不对CMakeLists.txt这个文件做修改的话，就非常容易导致编译出错！ 比如： in function `std::thread::thread<void (&)(int const&, char*), int&, char (&) [16], void>(void (&)(int const&, char*), i
Linux网络编程（3）——套接字编程（1）TCP协议实现
陌上人如玉，公子世无双。
06-28 328
源IP地址—目的地址：来自哪，到哪去 端口号：发往那个端口的数据应该由哪个进程来处理 一个端口只能被一个进程占用；一个进程可以多个端口占用。 每条数据有源端口号，目的端口号。 传输层协议选择： 有连接 VS 无连接： 有连接：双方必须都同意，才可以进行数据传输（打电话，必须等对方接通才能通话） 无连接：双方不一定都同意，也可以进行数据传输（发QQ，无论在不在线，你条件允许都能发...
python、c++编程面试题
qq_38109843的博客
04-20 432
线程池： 线程池是一种多线程处理形式，处理过程中将任务添加到队列，然后在创建线程后自动启动这些任务。线程池线程都是后台线程。每个线程都使用默认的堆栈大小，以默认的优先级运行，并处于多线程单元中。如果某个线程在托管代码中空闲（如正在等待某个事件）,则线程池将插入另一个辅助线程来使所有处理器保持繁忙。如果所有线程池线程都始终保持繁忙，但队列中包含挂起的工作，则线程池将在一段时间后创建另一个辅助线程但线...
由Linux中listen()函数谈开去
Litost_Cheng的博客
05-21 2251
由Linux中listen()函数谈开去 一、简介 1.前言 2.问题引入 二、原理介绍 1. Tcp三次握手 2. 关于backlog参数的理解 三、实验与分析 1. 实验环境 2. 例程介绍 3. 分步实验 1. Server阻塞于socket()创建后 2. Server阻塞于bind()创建后 3. Server阻塞于listen()后 4. Server阻塞...
线程池讲解（C++）|LinuxC/C++服务器开发
C/C++Linux、音视频、DPDK
05-21 643
1. 前言 线程池是一般服务端或者客户端编程经常要用到的一种管理线程的类，从网上找到一个比较好的线程池实现，主要运用C++11。记录一下理解过程，帮助学习线程池和C++11。 150行代码手写线程池 ：https://www.bilibili.com/video/BV1yQ4y1o7zv/ 2. 代码 2.1 先上代码 threadPool.hpp /* * @Author WangYubo * @Date 09/17/2018 * @Description 线程池实现的头文件 */ #ifnd
网路基础-VLAN
最新发布
梦想启航
08-13 1076
VLAN技术详解：构建高效安全网络的关键 VLAN（虚拟局域网）通过逻辑划分将物理局域网隔离为多个广播域，提升网络安全性（需路由跨VLAN通信）并优化流量管理。核心要点包括： VLAN类型：端口/MAC/协议/子网四种划分方式，端口静态分配最常见。 通信机制：同VLAN二层直连，跨VLAN需三层设备路由。 802.1Q标记：Trunk端口保留VLANTag（含VLANID、QoS优先级），Access端口剥离Tag。 转发实例：Access端口隔离不同VLAN，Trunk端口允许多VLAN透传，混合组网需匹
Linux网络编程实现TCP数据传输
本文将详细介绍如何使用C语言在Linux环境下实现TCP网络编程，包括TCP客户端和服务器端的数据传输代码。 ### TCP网络编程基础 在Linux环境下，进行TCP网络编程通常会使用到一些基础的系统调用函数，这些函数被封装...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值