devbox
羊村懒王
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

简单的UDP网络程序(后端服务器)_udp server

作者：羊村懒王 | 2024-03-02 10:43:05

赞

踩

udp server

目录

 

准备工作

makefile

udpServer.hpp

udpServer.cc

细节1

服务端部署

创建套接字

接口认识1

socket

协议家族

绑定套接字

认识接口2

bind

sockaddr_in结构体类型

细节2

bzero

inet_addr

服务器启动(初启动)

udpServer.hpp

udpServer.cc

细节3

本地回环通信

认识指令1

netstat

细节4

代码整改

整改后代码

udpServer.hpp

udpServer.cc

认识接口3

recvfrom

参数介绍

inet_ntoa

start启动

客户端部署

认识接口4

sendto

同一台云服务器上

不同的服务器上

通信和业务逻辑解耦

全部代码

udpServer.hpp

udpServer.cc

udpClient.hpp

udpClient.cc

makefile

准备工作

这些先在Xshell上创建，后续直接使用VScode来进行编码

makefile

udpServer.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5.  
  6. namespace Server
  7. {
  8.     class udpServer
  9.     {
  10.     public:
  11.         udpServer()
  12.         {
  13.         }
  14.         void initServer()   //初始化
  15.         {
  16.         }
  17.         void start()        //启动
  18.         {
  19.         }
  20.         ~udpServer()        //析构
  21.         {
  22.         }
  23.     };
  24.  
  25. }

udpServer.cc

  1. #include "udpServer.hpp"
  2. #include <memory>
  3.  
  4.  
  5. using namespace std;
  6. using namespace Server;
  7.  
  8. int main()
  9. {
  10.     std::unique_ptr<udpServer> usvr(new udpServer());
  11.  
  12.     usvr->initServer();
  13.     usvr->start();
  14.  
  15.  
  16.     return 0;
  17. }

细节1

服务端部署

创建套接字

接口认识1

socket

参数

返回值

读写网络就像读写文件一样

初始化代码写到构造里面了，后面修改

协议家族

绑定套接字

认识接口2

bind

 这里的填充涉及到内存对齐方面，知道就好

sockaddr_in结构体类型

对类型进行了很多层的封装

细节2

从上面看到，我们可以得到一个问题：为什么库里面使用的是整型的ip地址，而我们是用string的ip地址的呢？

点分十进制和整数风格互转

bzero

往一段空间中填 0 

inet_addr

记得包含头文件

getopt

附：当我们想要做命令行解析的时候是可以用下面这个接口的，这里我们不使用(参数太少了，没必要使用)

服务器启动(初启动)

至此服务器已经可以正常启动

udpServer.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <strings.h>
  6. #include <cerrno>
  7. #include <cstring>
  8. #include <unistd.h>
  9. #include <sys/types.h>
  10. #include <sys/socket.h>
  11. #include <arpa/inet.h>
  12. #include <netinet/in.h>
  13.  
  14. namespace Server
  15. {
  16.     using namespace std;
  17.     static const string defaultIp = "0.0.0.0";  //TODO
  18.  
  19.     enum {USAGE_ERR = 1, SOCKET_ERR, BIND_ERR}; //1.命令行输入错误 2.创建套接字错误 3.绑定端口号错误
  20.     class udpServer
  21.     {
  22.     public:
  23.         udpServer(const uint16_t &port, const string& ip = defaultIp): _port(port),_ip(ip),_sockfd(-1)
  24.         {
  25.             //注意这里是直接写在构造里面的，是写错地方了，虽然运行是没有错的，由于修改图片太麻烦，下面统一进行了修改
  26.             //1.创建套接字
  27.             _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
  28.             if(_sockfd == -1)
  29.             {
  30.                 cerr << "socket error: " << errno << " : " << strerror(errno) << endl;
  31.                 exit(SOCKET_ERR);   //创建套接字失败直接终止进程
  32.             }
  33.             //2.绑定套接字(port, ip)
  34.             struct sockaddr_in local;   //这里是定义了一个变量，在栈上，而且是用户层，还没有bind之前都是没有产生联系
  35.             bzero(&local, sizeof(local));   //先填 0 再修正
  36.             //注意这下面几个名字是拼接出来的，就是那个##拼接而来的
  37.             local.sin_family = AF_INET; //这里设置与套接字的AF_INET设置意义是不一样的，socket是创建一个网络通信的套接字，在这里是填充一个sockaddr_in的结构体用来网络通信
  38.             local.sin_port = htons(_port);//你如果给别人发信息，你的port和ip要不要发送给对方？ 答案是要的 
  39.             local.sin_addr.s_addr = inet_addr(_ip.c_str()); //1. string->unit32_t  2. htonl(); -> inet_addr 
  40.             int n = bind(_sockfd, (struct sockaddr*)&local, sizeof(local));
  41.             if(n == -1)
  42.             {
  43.                 cerr << "bin error: " << errno << " : " << strerror(errno) << endl;
  44.                 exit(BIND_ERR);
  45.             }
  46.             //UDP Server 的预备工作完成
  47.  
  48.         }
  49.         void initServer() // 初始化
  50.         {
  51.         }
  52.         void start() // 启动
  53.         {
  54.             //服务器的本质其实就是一个死循环,
  55.             for(;;)
  56.             {
  57.                 sleep(1);
  58.             }
  59.         }
  60.         ~udpServer() // 析构
  61.         {
  62.         }
  63.  
  64.     private:
  65.         uint16_t _port;
  66.         string _ip; // TODO
  67.         int _sockfd;
  68.     };
  69. }

udpServer.cc

  1. #include "udpServer.hpp"
  2. #include <memory>
  3.  
  4. using namespace std;
  5. using namespace Server;
  6.  
  7. static void Usage(string proc)
  8. {
  9.     cout << "Usage:\n\t" << proc << " local_ip local_port\n\n"; //命令提示符
  10. }
  11.  
  12. int main(int argc, char *argv[])
  13. {
  14.     if(argc != 3)   //这里我们只想要传递两个参数，所以当argc不是3的时候就直接报错退出就行了，注意文件名运行的那个指令也会算进去所以argc +1
  15.     {
  16.         Usage(argv[0]);
  17.         exit(USAGE_ERR);
  18.     }
  19.     uint16_t port = atoi(argv[2]);  //使用atoi强转，因为argv里面放置的都是字符串，类型需要转换
  20.     string ip = argv[1];
  21.  
  22.     std::unique_ptr<udpServer> usvr(new udpServer(port, ip));
  23.  
  24.     usvr->initServer();
  25.     usvr->start();
  26.  
  27.  
  28.     return 0;
  29. }

认识接口2

细节3

刚开始测试的地址是直接使用这一个

本地回环通信

127.0.0.1

认识指令1

netstat

查看网络的接口 netstat

细节4

假如绑定其他的公网IP地址需要注意

代码整改

所以一个服务器真实情况下是要接受任意ip发过来的通信，因此我们修改ip的，不需要传ip号了

整改后代码

udpServer.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <strings.h>
  6. #include <cerrno>
  7. #include <cstring>
  8. #include <unistd.h>
  9. #include <sys/types.h>
  10. #include <sys/socket.h>
  11. #include <arpa/inet.h>
  12. #include <netinet/in.h>
  13.  
  14. namespace Server
  15. {
  16.     using namespace std;
  17.     static const string defaultIp = "0.0.0.0"; // 直接使用这个缺省值
  18.  
  19.     enum
  20.     {
  21.         USAGE_ERR = 1,
  22.         SOCKET_ERR,
  23.         BIND_ERR
  24.     }; // 1.命令行输入错误 2.创建套接字错误 3.绑定端口号错误
  25.     class udpServer
  26.     {
  27.     public:
  28.         udpServer(const uint16_t &port, const string &ip = defaultIp) : _port(port), _ip(ip), _sockfd(-1)
  29.         {}
  30.         void initServer() // 初始化
  31.         {
  32.             // 1.创建套接字
  33.             _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
  34.             if (_sockfd == -1)
  35.             {
  36.                 cerr << "socket error: " << errno << " : " << strerror(errno) << endl;
  37.                 exit(SOCKET_ERR); // 创建套接字失败直接终止进程
  38.             }
  39.             // 2.绑定套接字(port, ip)
  40.             struct sockaddr_in local;     // 这里是定义了一个变量，在栈上，而且是用户层，还没有bind之前都是没有产生联系
  41.             bzero(&local, sizeof(local)); // 先填 0 再修正
  42.             // 注意这下面几个名字是拼接出来的，就是那个##拼接而来的
  43.             local.sin_family = AF_INET;                     // 这里设置与套接字的AF_INET设置意义是不一样的，socket是创建一个网络通信的套接字，在这里是填充一个sockaddr_in的结构体用来网络通信
  44.             local.sin_port = htons(_port);                  // 你如果给别人发信息，你的port和ip要不要发送给对方？ 答案是要的
  45.             local.sin_addr.s_addr = inet_addr(_ip.c_str()); // 1. string->unit32_t  2. htonl(); -> inet_addr
  46.             // local.sin_addr.s_addr = htonl(INADDR_ANY);  //可以主机转网络，不够也可以不处理，直接赋值也行
  47.             int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
  48.             if (n == -1)
  49.             {
  50.                 cerr << "bin error: " << errno << " : " << strerror(errno) << endl;
  51.                 exit(BIND_ERR);
  52.             }
  53.             // UDP Server 的预备工作完成
  54.         }
  55.         void start() // 启动
  56.         {
  57.             // 服务器的本质其实就是一个死循环,
  58.             for (;;)
  59.             {
  60.                 sleep(1);
  61.             }
  62.         }
  63.         ~udpServer() // 析构
  64.         {
  65.         }
  66.  
  67.     private:
  68.         uint16_t _port;
  69.         // 实际上，一款网络服务器，不建议指明一个IP，因为一个服务器可以能有多个ip，万一用户使用其他的ip地址来访问该端口号(这里是8080,就收不到了)，这也是我们为什么使用0.0.0.0的IP缺省值
  70.         string _ip;
  71.         int _sockfd;
  72.     };
  73. }

udpServer.cc

  1. #include "udpServer.hpp"
  2. #include <memory>
  3.  
  4. using namespace std;
  5. using namespace Server;
  6.  
  7. static void Usage(string proc)
  8. {
  9.     cout << "Usage:\n\t" << proc << " local_port\n\n"; //命令提示符
  10. }
  11.  
  12. int main(int argc, char *argv[])
  13. {
  14.     if(argc != 2)   //这里我们只想要传递两个参数，所以当argc不是3的时候就直接报错退出就行了，注意文件名运行的那个指令也会算进去所以argc +1
  15.     {
  16.         Usage(argv[0]);
  17.         exit(USAGE_ERR);
  18.     }
  19.     uint16_t port = atoi(argv[1]);  //使用atoi强转，因为argv里面放置的都是字符串，类型需要转换
  20.     //string ip = argv[1];
  21.  
  22.     std::unique_ptr<udpServer> usvr(new udpServer(port));
  23.  
  24.     usvr->initServer();
  25.     usvr->start();
  26.  
  27.  
  28.     return 0;
  29. }

        注意这里是服务端是不需要IP，可以接受任意IP地址发来的请求，但是客户端是需要的，这一点后面再细谈，所以并不会造成淘宝的请求跑到京东去了

        这里为什么使用8080的因为服务器可以有很多端口号，当服务器收到了大量的数据，并不是全部都是由一个端口号来进行处理的，也可能是8081之类的端口号，这时候的端口号是没有意义的，后序会详谈，其实不同的端口号是有指定的绑定的不能任意绑定，这是因为只有我自己使用

        且无论是UDP还是TCP都是采取这样的形式，接受任意IP的数据，通过端口号来确定谁是谁处理

认识接口3

recvfrom

读取数据

参数介绍

socket_t

inet_ntoa

        将一个网络字节序的IP地址（也就是结构体in_addr类型变量）转化为点分十进制的IP地址（字符串）

 

start启动

  1. void start() // 启动
  2.         {
  3.             // 服务器的本质其实就是一个死循环
  4.             char buffer[gnum]; // 定义一个数组来充当缓冲区
  5.             for (;;)
  6.             {
  7.                 // 读取数据
  8.                 struct sockaddr_in peer;
  9.                 socklen_t len = sizeof(peer); // 必须设置成这个结构体的大小，当作为输入时，告诉recvfrom的长度的多少
  10.                 ssize_t s = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
  11.                 // 关系两件事情
  12.                 // 1.数据是什么？ 2. 谁发的？
  13.                 if (s > 0)
  14.                 {
  15.                     buffer[s] = 0;
  16.                     // 因为是从网络上读取的，所以一定要转，可以使用接口
  17.                     string clientip = inet_ntoa(peer.sin_addr); // 1.网络序列 2.整数 -> 点分十进制的ip
  18.                     uint16_t clientport = ntohs(peer.sin_port);
  19.                     string message = buffer;
  20.  
  21.                     cout << clientip << "[" << clientport << "]# " << message << endl;
  22.                 }
  23.             }
  24.         }

至此服务器端基本完成，停下来处理客户端

客户端部署

认识接口4

sendto

sendto告诉客户端要发给谁

0~1023在云服务器上已经被绑定了 

同一台云服务器上

不同的服务器上

现在无法跨主机发送消息，权限问题，后续解决

sz：下载到本地

rz：上传到服务器

chmod：修改权限

注意一台新的云服务器

至于如何打开端口后续文章介绍 -- 未完持续

通信和业务逻辑解耦

        我们可以添加function来对业务逻辑进行解耦操作，融入下面代码

        function对server通信和业务逻辑解耦！

全部代码

udpServer.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <strings.h>
  6. #include <cerrno>
  7. #include <functional>
  8. #include <cstring>
  9. #include <unistd.h>
  10. #include <sys/types.h>
  11. #include <sys/socket.h>
  12. #include <arpa/inet.h>
  13. #include <netinet/in.h>
  14.  
  15. namespace Server
  16. {
  17.     using namespace std;
  18.     static const string defaultIp = "0.0.0.0"; // 直接使用这个缺省值
  19.     static const int gnum = 1024;
  20.     enum
  21.     {
  22.         USAGE_ERR = 1,
  23.         SOCKET_ERR,
  24.         BIND_ERR
  25.     }; // 1.命令行输入错误 2.创建套接字错误 3.绑定端口号错误
  26.  
  27.     typedef function<void(string, uint16_t, string)> func_t;
  28.  
  29.     class udpServer
  30.     {
  31.     public:
  32.         udpServer(const func_t &cd, const uint16_t &port, const string &ip = defaultIp)
  33.             : _callback(cd), _port(port), _ip(ip), _sockfd(-1)
  34.         {
  35.         }
  36.         void initServer() // 初始化
  37.         {
  38.             // 1.创建套接字
  39.             _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
  40.             if (_sockfd == -1)
  41.             {
  42.                 cerr << "socket error: " << errno << " : " << strerror(errno) << endl;
  43.                 exit(SOCKET_ERR); // 创建套接字失败直接终止进程
  44.             }
  45.             cout << "udpServer success: "
  46.                  << " : " << _sockfd << endl;
  47.  
  48.             // 2.绑定套接字(port, ip)
  49.             // 未来服务器要明确的port， 不能随意改变 -- 变了别人就找不到了
  50.             struct sockaddr_in local;     // 这里是定义了一个变量，在栈上，而且是用户层，还没有bind之前都是没有产生联系
  51.             bzero(&local, sizeof(local)); // 先填 0 再修正
  52.             // 注意这下面几个名字是拼接出来的，就是那个##拼接而来的
  53.             local.sin_family = AF_INET;                     // 这里设置与套接字的AF_INET设置意义是不一样的，socket是创建一个网络通信的套接字，在这里是填充一个sockaddr_in的结构体用来网络通信
  54.             local.sin_port = htons(_port);                  // 你如果给别人发信息，你的port和ip要不要发送给对方？ 答案是要的
  55.             local.sin_addr.s_addr = inet_addr(_ip.c_str()); // 1. string->unit32_t  2. htonl(); -> inet_addr
  56.             // local.sin_addr.s_addr = htonl(INADDR_ANY);  //可以主机转网络，不够也可以不处理，直接赋值也行
  57.             int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
  58.             if (n == -1)
  59.             {
  60.                 cerr << "bin error: " << errno << " : " << strerror(errno) << endl;
  61.                 exit(BIND_ERR);
  62.             }
  63.             // UDP Server 的预备工作完成
  64.         }
  65.         void start() // 启动
  66.         {
  67.             // 服务器的本质其实就是一个死循环
  68.             char buffer[gnum]; // 定义一个数组来充当缓冲区
  69.             for (;;)
  70.             {
  71.                 // 读取数据
  72.                 struct sockaddr_in peer;
  73.                 socklen_t len = sizeof(peer); // 必须设置成这个结构体的大小，当作为输入时，告诉recvfrom的长度的多少
  74.                 ssize_t s = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
  75.                 // 关系两件事情
  76.                 // 1.数据是什么？ 2. 谁发的？
  77.                 if (s > 0)
  78.                 {
  79.                     buffer[s] = 0;
  80.                     // 因为是从网络上读取的，所以一定要转，可以使用接口
  81.                     // inet_ntoa 将一个网络字节序的IP地址（也就是结构体in_addr类型变量）转化为点分十进制的IP地址（字符串）
  82.                     string clientip = inet_ntoa(peer.sin_addr); // 1.网络序列 2.整数 -> 点分十进制的ip
  83.                     uint16_t clientport = ntohs(peer.sin_port);
  84.                     string message = buffer;
  85.  
  86.                     cout << clientip << "[" << clientport << "]# " << message << endl;
  87.  
  88.                     //我们只把数据读上来就完了吗？ 我们要对数据进行处理 -- 所以我们用回调函数的方式来解决
  89.                     _callback(clientip, clientport, message);
  90.                 }
  91.             }
  92.         }
  93.         ~udpServer() // 析构
  94.         {
  95.         }
  96.  
  97.     private:
  98.         uint16_t _port;
  99.         // 实际上，一款网络服务器，不建议指明一个IP，因为一个服务器可以能有多个ip，万一用户使用其他的ip地址来访问该端口号(这里是8080,就收不到了)，这也是我们为什么使用0.0.0.0的IP缺省值
  100.         string _ip;
  101.         int _sockfd;
  102.         func_t _callback; // 回调函数，用以处理数据
  103.     };
  104. }

udpServer.cc

  1. #include "udpServer.hpp"
  2. #include <memory>
  3.  
  4. using namespace std;
  5. using namespace Server;
  6.  
  7. static void Usage(string proc)
  8. {
  9.     cout << "Usage:\n\t" << proc << " local_port\n\n"; //命令提示符
  10. }
  11.  
  12.  
  13. void handlerMessage(string clientip, uint16_t clientport, string message)
  14. {
  15.     //这里就可以对message进行特定的业务处理，而不关心message怎么来的 --- 这就是server通信和业务逻辑解耦！
  16. }
  17.  
  18. int main(int argc, char *argv[])
  19. {
  20.     if(argc != 2)   //这里我们只想要传递两个参数，所以当argc不是3的时候就直接报错退出就行了，注意文件名运行的那个指令也会算进去所以argc +1
  21.     {
  22.         Usage(argv[0]);
  23.         exit(USAGE_ERR);
  24.     }
  25.     uint16_t port = atoi(argv[1]);  //使用atoi强转，因为argv里面放置的都是字符串，类型需要转换
  26.     //string ip = argv[1];
  27.  
  28.     std::unique_ptr<udpServer> usvr(new udpServer(handlerMessage, port));
  29.  
  30.     usvr->initServer();
  31.     usvr->start();
  32.  
  33.  
  34.     return 0;
  35. }

udpClient.hpp

  1. #pragma once
  2.  
  3. #include <iostream>
  4. #include <string>
  5. #include <strings.h>
  6. #include <cerrno>
  7. #include <cstring>
  8. #include <unistd.h>
  9. #include <sys/types.h>
  10. #include <sys/socket.h>
  11. #include <arpa/inet.h>
  12. #include <netinet/in.h>
  13.  
  14. namespace Client
  15. {
  16.     using namespace std;
  17.     class udpClient
  18.     {
  19.     public:
  20.         udpClient(const string &serverip, const uint16_t &serverport)
  21.             : _serverip(serverip), _serverprot(serverport), _sockfd(-1), _quit(false)
  22.         {
  23.         }
  24.         void initClient()
  25.         {
  26.             // 1. 创建socket
  27.             _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
  28.             if (_sockfd == -1)
  29.             {
  30.                 cerr << "socket error: " << errno << " : " << strerror(errno) << endl;
  31.                 exit(1); // 创建套接字失败直接终止进程
  32.             }
  33.             cout << "socket success: " << " : " << _sockfd << endl;   //成功打印出来
  34.  
  35.             // 2. client要不要bind（必须要！）因为bind就是和系统、网络产生联系. client要不要显示的bind -> 需不需要程序员bind？ 名字不重要，重要的是唯一性的，和服务端是不一样的
  36.             // 就像宿舍号是几不重要，有就行了。一个端口号只能被一个客户端绑定，就像是服务端是明星，客户端是民众，民众名字不重要
  37.             // 服务端是具体的一家公司，比如抖音是字节的，就像一个手机有很多app比如抖音，快手这样的客户端，不能让它们固定bind端口号，万一其他公司也用了用一个端口就冲突其他不来了
  38.             // 写服务器的是一家公司，写client是无数家公司 -- 有OS自动形成端口进行bind！不需要自己操作，包括ip地址也不需要，OS自己会处理，当然也可以自己写
  39.             // 那么OS在什么时候，如何bind
  40.         }
  41.         void run()
  42.         {
  43.             struct sockaddr_in server;
  44.             memset(&server, 0, sizeof(server));
  45.             server.sin_family = AF_INET;
  46.             server.sin_addr.s_addr = inet_addr(_serverip.c_str());
  47.             server.sin_port = htons(_serverprot);
  48.  
  49.             string messages;
  50.             while (!_quit)
  51.             {
  52.                 cout << "Please Enter# ";
  53.                 cin >> messages;
  54.  
  55.                 sendto(_sockfd, messages.c_str(), sizeof(messages), 0, (struct sockaddr *)&server, sizeof(server));
  56.             }
  57.         }
  58.         ~udpClient()
  59.         {
  60.         }
  61.  
  62.     private:
  63.         int _sockfd;
  64.         string _serverip;
  65.         uint16_t _serverprot;
  66.         bool _quit;
  67.     };
  68.  
  69. }

udpClient.cc

  1. #include "udpClient.hpp"
  2. #include <memory>
  3.  
  4. using namespace Client;
  5.  
  6. static void Usage(string proc)
  7. {
  8.     cout << "\nUsage:\n\t" << proc << " server_ip server_port\n\n"; //命令提示符
  9. }
  10.  
  11. // ./udpClient server_ip server_port    第一个是运行方式 要知道要发送的服务端的ip地址 和 端口号
  12. int main(int argc, char *argv[])
  13. {
  14.     if(argc != 3)
  15.     {
  16.         Usage(argv[0]);
  17.         exit(1);
  18.     }
  19.     string serverip = argv[1];
  20.     uint16_t serverport = atoi(argv[2]);
  21.  
  22.  
  23.     unique_ptr<udpClient> ucli(new udpClient(serverip, serverport));
  24.  
  25.     ucli->initClient();
  26.     ucli->run();
  27.  
  28.     return 0;
  29. }

makefile

  1. cc=g++
  2.  
  3. .PHONY:all
  4. all:udpClient udpServer
  5.  
  6.  
  7. udpClient:udpClient.cc
  8. 	$(cc) -o $@ $^ -std=c++11 
  9. udpServer:udpServer.cc
  10. 	$(cc) -o $@ $^ -std=c++11
  11.  
  12. .PHONY:clean
  13. clean:
  14. 	rm -f udpClient udpServer

至于如何打开端口后续文章介绍 -- 简单的UDP网络程序·续写

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/羊村懒王/article/detail/179943
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号