基于UDP的简易网络通信程序

客户端想要将信息发送到服务器端主机，客户端用户在客户端主机的应用层输入的数据，必须要自顶向下贯穿TCP/IP网络协议栈，并封装每一层的协议报头， 然后到达物理层的设备，然后通过物理的介质将信息传输到服务器端主机的物理层的设备 ，然后将信息**自底向上贯穿TCP/IP协议栈，进行解包和分用，**将客户端用户输入的信息传输到服务器端应用层的程序。

服务器端主机给客户端主机发送的信息也是如此。

如果你想要更加细致的研究这个过程可以参考这篇文章：文章链接https://blog.csdn.net/D5486789_/article/details/142029716?spm=1001.2014.3001.5501

IP地址

什么是IP地址呢？我们可以这样理解。假如A主机想要将信息发送到B主机，但是在整个网络中的主机数量非常多，所以A主机必须要知道那一台主机是B主机，这个时候，就可以给每一台主机一个编号，用户在网络中标识唯一的一台主机，这个编号就是IP地址。由于历史发展的原因，IP地址有IPV4和IPV6两个版本，但我们主要使用IPV4。

IPv4地址由32位二进制数组成，通常用点分十进制的方式来表示，即每组8位二进制数转换成一个十进制数，并用点（.）分隔，例如192.168.1.1。

端口号（port）

什么是端口号呢？我们可以这样理解。当A主机已经有能力通过IP地址在网络中如此众多的主机中找到B主机，并将信息发送到B主机在物理层的设备上，此时消息需要自底向上贯穿TCP/IP协议栈交付到B主机的应用层，但是B主机应用层启动的软件程序可能不止一个 ，发送的消息到底要交付给哪一个软件程序呢？所以，A主机还需要有能力将发送给B主机的信息正确的交付给B主机中对应的软件程序。这个时候可以给每个启动的软件程序一个编号，用于唯一的标识一个启动的软件程序，这个编号就是端口号。

端口号是一个16位的数字，范围从0到65535。 其中，一些端口号被预留给特定的服务或应用程序，这些端口号被称为"知名端口号"或"系统端口号"。例如，HTTP服务通常使用端口号80，HTTPS服务通常使用端口号443，FTP服务使用端口号21等。这些知名端口号在Internet上被广泛认可和使用，使得客户端可以很容易地找到并连接到相应的服务。客户端程序的端口号在1024之后随便选。

如果你有操作系统的知识的话，你就知道我上面所说的软件程序就是操作系统中的进程，但是标识系统中唯一的一个进程不是有进程PID吗？为什么还要端口号呢？

我们可以这样理解：

**用户使用角度：**用户访问服务器端的服务程序的时候，需要知道该服务的IP地址和端口号，并且用户一旦认定了这个IP地址和端口号，当用户再次想访问对应的服务的时候，输入的还是这个IP地址和端口号，所以这就要求服务端程序所在主机的IP地址和自己的端口号是不能改变的；但是进程PID不同，每次启动同一个程序时，系统分配给进程的PID是会变化的，所以在网络通信中不能使用进程PID来唯一标识唯一的一个进程。

从操作系统的角度： 进程PID是属于操作系统中进程管理的范畴，网络通信是数据操作系统中网络管理的范畴，不同的模块之间最好是低耦合的，一层变化不会影响另一层。所以，操作系统中网络管理模块需要有独属于自己的，用于唯一的标识一个进程的设计，这个设计就是端口号。

总结： 不同的两台主机之间通信，必须要提前知道对方的IP地址和端口号，这样才能在整个错综复杂的网络中有目的的找到对方，并将信息准确的交付给对方启动的应用程序。

客户端如何得知服务器端的IP地址和端口号？

客户端需要知道服务器端的IP地址和端口号，那客户端是如何得知服务器端的IP地址和端口号的呢？

我们可以设想一下，开发人员开发出一个应用服务之后，要如何让别人来访问自己开发出的应用服务呢？是不是需要提前告诉用户呢？只有提前告诉用户，用户才知道访问对应的服务需要输入特定的IP地址和端口号。

但是IP地址和端口号太难记忆了，不方便用户使用，于是，便有了域名。比如，当我们想要买东西时，我们就可以在浏览器输入 www.taobao.com，浏览器就会将用户输入的域名解析成为指定的IP地址和端口号。

所以，客户端要想得知服务器端的IP地址和端口号，一定是商业公司提前做了宣传。

服务器端如何得知客户端的IP地址和端口号？

那服务器端是如何得知客户端的IP地址和端口号的呢？

我们可以这样理解：当用户输入指定的IP地址和端口号之后，用户输入的信息在自定向下贯穿TCP/IP协议栈的时候，不是会进行封装吗？这个过程就会将用户所使用的主机的IP地址和该主机上客户端程序的端口号也封装进用户发送的数据中，形成一个数据包，当服务器端拿到这个数据包时，就能知道客户端的IP地址和端口号。

所以，服务器端之所以能知道客户端的IP地址和端口号，是客户端发送给服务器端的。

好了，有了上面这些知识，我们就可以编写代码了。但是还有一些网络通信的基础知识在 "实现代码" 部分讲解。

2.实现代码

注意，在使用网络编程相关接口时，我们需要包含这四个头文件

#include <sys/types.h>

#include <sys/socket.h>

#include <arpa/inet.h>

#include <netinet/in.h>

代码模块的设计

客户端只需要实现UdpClient.cc，服务器端需要实现UdpServer.hpp、Main.cc。

服务器端代码

服务器类代码总览：

成员说明

成员变量说明：

在整个服务器类中，成员变量我们设计三个，分别是_sockfd、_port。

_sockfd：这是一个文件描述符，服务器端程序在进行网络通信的过程中，接收的数据从该文件描述符所关联的文件中拿；发送的数据，通过该文件描述符所关联的文件发送。

_port：这是服务器端程序所使用的端口号，是我们开发人员给手动的给服务器端程序绑定的。

成员函数说明：

在真个服务器类中一共四个成员函数，分别是 UdpServer(uint16_t port)、 ~UdpServer()、 void InitServer()、 void Start()。

UdpServer(uint16_t port)：构造函数，负责成员变量的初始化，将_port 初始化为我们开发人员给服务器端程序指定的port；port是在启动服务器端程序时，我们自己指定的。

~UdpServer()：析构函数，负责成员变量的释放，但并没有成员变量管理资源，所以不需要写啥。

void InitServer()：该成员函数负责初始化服务器端程序，也就是为网络通信做必要的准备。比如：创建套接字，绑定端口号。

void Start()：该成员函数负责启动服务器，当调用这个函数之后，我们的服务器端程序就可以进行消息的收和发了。

成员实现

成员实现部分，我们主要实现成员函数。

UdpServer(uint16_t port) 的实现

_sockfd我们先初始化为defaultfd，这是我们定义的const 静态全局变量，也就是-1。

_port 成员变量初始化为port，port 是需要我们在启动服务器端程序时手动输入的。

_isrunnig 大家不用管，不影响。

UdpServer(uint16_t port) 
    : _sockfd(defaultfd)
    , _port(port)
    , _isrunning(false)
{}

~UdpServer() 的实现

额，这个嘛，确实没啥要析构的，使用默认的就可以。

~UdpServer()
{}

void InitServer() 的实现

这个成员方法的实现我们分为两步，第一步为创建udp socket套接字，第二步为绑定本地信息和网络信息。

先看看代码：后面有非常详细的解释。

void InitServer()
{
    // 1. 创建udp socket 套接字
    _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (_sockfd < 0)
    {
        LOG(FATAL, "socket error, %s, %d\n", strerror(errno), errno);
        exit(SOCKET_ERROR);
    }
    LOG(INFO, "socket create success, sockfd: %d\n", _sockfd);

    // 填充sockaddr_in结构
    struct sockaddr_in local; 
    bzero(&local, sizeof(local)); //将该字段全部清空为0.
    local.sin_family = AF_INET;
    local.sin_port = htons(_port);
    local.sin_addr.s_addr = INADDR_ANY; // htonl(INADDR_ANY);

    // 2.bind sockfd和网络信息(IP + Port)
    int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
    if (n < 0)
    {
        LOG(FATAL, "bind error, %s, %d\n", strerror(errno), errno);
        exit(BIND_ERROR);
    }
    LOG(INFO, "socket bind success\n");
}

第一步解释：

我们首先创建udp socket。大家可以这样理解，服务器端的程序需要进行消息的收和发，收消息一定是该主机的物理层的网络设备先收到，也就是网卡，网卡收到的消息要放在哪里呢？在回答这个问题之前，我们需要先明确一点 "Linux下一切皆文件"，硬件也是一种文件。所以操作系统要为网卡分配一个收发消息的缓冲区，用来存放收到的消息和发送的消息。再简单一点理解就是，创建udp socket，相当于把网卡打开了，就可以通过网卡收发消息了。

第一步实现：

实现第一步需要使用这个函数：

**函数功能：**通过制定的协议创建用于网络通信的文件。

**第一个参数：**domain 表明我们要进行何种通信，是本地通信，还是网络通信，我们实现的是网络通信，所以将domain设置为 AF_INET即可。

**第二个参数：**type 指定了套接字的类型，是面向数据报的套接字类型还是面向字节流的套接字类型，UDP是面向数据报的通信协议，所以我们将其设置为SOCK_DGRAM即可。

**第三个参数：**protocol 用于指定特定的协议，但是前两个参数已经表明我们要使用UDP协议了，所以设置为0即可。

返回类型：

**失败时：**返回-1，并设置错误码。

成功时： 返回新创建的文件描述符。这个文件描述符后续会被用于其他套接字函数，如**bind()、listen()、accept()、connect()、send()、recv()**等，这也是我们设计一个_sockfd 成员变量的原因。
第二步解释：

前面我们说过，socket函数返回值是一个文件描述符，与该文件描述符所关联的文件用于该主机在网络通信中收发数据；可是，光光有一个收发数据的文件，还是远远不够的，还需要将该文件和主机的网络信息（比如IP地址，端口号等）关联起来，这样，客户端就能通过指定的IP地址和端口号，找到提供服务的服务端程序，并向该程序用于网络通信的文件中发送数据。服务器端向客户端发送消息也是如此。

第二步实现：

实现这一步需要使用bind函数：

**函数功能：**将通信主机的本地信息(sockfd)和网络信息关联起来。

**第一个参数：**sockfd 是我们需要关联的文件描述符。

第二个参数： struct sockaddr 中包含本机的网络信息。

第三个参数： 这个参数指定了 addr 参数所指向的结构的长度。对于 sockaddr_in，这个长度通常是 sizeof(struct sockaddr_in)

说明一下：

addr的类型是 struct sockaddr，但实际上addr的类型是 struct sockaddr_in。这是因为，socket编程不仅可以用于网络通信（使用struct sockaddr_in结构），还可以用于本地通信（使用struct sockaddr_un结构），还有其他通信......通信方式这么多，操作系统的开发者就要多开发几套通信接口给用户使用，不仅仅开发的人头疼，使用的人也头疼。于是，操作系统的开发人员便想到一种方案，提供统一的接口，用户想要进行那种通信，就传入特定的参数即可，该函数内部自动做解析，判断用户要进行何种通信。也就是说，为了统一接口的使用，设计了struct sockaddr 类型。

需要注意的是，这个参数是一个结构体类型，所以我们需要先填充结构体中的字段之后，再将该结构体对象作为参数传递进去。struct sockaddr_in结构中的字段如下所示：
struct sockaddr_in {  
    sa_family_t    sin_family;   // 地址族，对于 IPv4 来说，这个值总是 AF_INET  
    uint16_t       sin_port;     // 端口号，网络字节顺序  
    struct in_addr sin_addr;     // IPv4 地址，网络字节顺序    
};  
  
// 其中，struct in_addr 结构体定义如下：  
struct in_addr {  
    uint32_t s_addr; // IPv4 地址，网络字节顺序  
};
sin_family：我们设置为AF_INET，表示要进行网络通信。

sin_port：表示我们给该服务器端程序绑定的端口号。

sin_addr：表示该服务器端程序所在主机的IP地址。

htons和htonl函数的介绍：

**函数功能：**将主机序列转换成网络序列。

由于历史发展的原因，产生了大端机和小端机，大端机和小端机之间可能也要进行通信，数据需要经过网络，那么数据在网络中是大端序列还是小端序列呢？为了解决这个问题，网络中的序列被规定为大端序列，小端机发送的数据要经过网络就需要转化成网络序列，也就是大端序列，大端机发送的数据已经是大端的了，就不需要进行转化了。

对于IP地址，在主机中显示的时候，显示出来的是 点分十进制的IP地址， 但是，在网络中传输的时候，为了节省空间，往往被设计为四字节的IP地址。

所以我们发送的端口号 需要转换成网络序列，需要使用htons函数，表示将一个16位的整数转换成网络序列。

发送的IP地址 需要转换成四字节的IP ，同时也需要转换成网络序列，需要使用htonl函数，这一个函数会帮我们完成这两步事情。

这句代码是什么意思呢？------ local.sin_addr.s_addr = INADDR_ANY;

我们将 local.sin_addr.s_addr 设置为INADDR_ANY，这是为什么呢？因为如果我们指定了服务器端的IP地址，客户端只能通过特定的IP地址来访问这个服务端程序， 也就是说这个服务端程序只能通过绑定的IP地址来访问；但是一台主机不止一个IP地址，可能有公网IP，内网IP，不同的IP需要提供给不同的用户使用，需要保证用户使用该主机的不同IP地址能访问到指定的服务端程序。所以我们将服务器端的IP地址绑定为0，在代码实现方面，库当中将INADDR_ANY定义为0，并且0 的大端序列和小端序列是相同的。

void Start() 的实现

当我们完成服务器端程序网络通信的初始化工作之后，我们的服务器端程序就可以通信了，这段代码也体现了我们这个通信程序的功能 ------ 接收客户端的消息，给客户端返回同样的消息。

先看代码再解释：

void Start()
{
    // 一直运行，直到管理者不想运行了， 服务器都是死循环
    // UDP是面向数据报的协议
    while (true)
    {
        char buffer[1024];
        struct sockaddr_in peer;
        socklen_t len = sizeof(peer); // 必须初始化成为sizeof(peer)
        // 1. 我们要让server先收数据
        ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
        if (n > 0)
        {
            buffer[n] = 0;
            LOG(DEBUG, "get message: %s\n",  buffer);
            // 2. 我们要将server收到的数据，发回给对方
            sendto(_sockfd, buffer, strlen(buffer), 0, (struct sockaddr *)&peer, len);
        }
    }
}

先介绍基于UDP协议进行网络通信的两个函数：

我们的程序是基于UDP协议进行通信的，UDP协议是面向数据报的协议，所以我们不能使用一般的文件读写接口从基于UDP网络通信的文件中读写数据，而要使用UDP协议的网络通信读写接口 ------ recvfrom和sendto。

recvfrom：

函数功能：从指定的网络通信文件中读取数据。

参数说明：

1.sockfd表明我们要从那个文件中读。

2.buf是一个输出型参数，表明我们读取的数据放到哪里。

3.len表明我们要读取多长的数据。

4.flags是一个标志位，表示我们以什么方式读，通常设为0。

5.src_addr 表明发送数据方的网络信息( 比如：发送方的IP地址和端口号信息。)，也就是说要知道是谁给我发的消息。

6.addrlen 是指向一个整数的指针，该整数在调用前应该包含 src_addr 指向的结构体的大小；在调用后，它将包含实际写入 src_addr 的字节数。

**返回值：**该函数执行成功的返回值表示接收到的字节数。如果连接已正常终止，则返回0。如果发生错误，则返回-1，并设置相应的errno来指示错误的类型。

sendto：

函数功能：通过指定的网络通信文件发送数据。

参数介绍：

1.sockfd表示我们要通过哪个通信文件发送数据。

2.buf 表示我们要发送的数据在内存中存储的位置。

3.len 表明我们要发送多长的数据。

4.flags 表明我们要以什么方式发送数据。

5.dest_addr 表明**接收数据方的网络信息，**也就是说要把数据发送给谁。

6.addrlen 表明dest_addr所指向的对象的大小。

**返回值：**如果发送成功，则返回发送的字节数（可能小于请求发送的字节数，如果发送缓冲区空间不足或网络限制）。如果发生错误，则返回-1，并设置errno来指示错误的类型。

代码解释：

作为服务器端程序，肯定是需要一直运行的，这样才能确保客户随时随地都能访问，所以是在一个死循环中，直到管理者不想让这个程序执行了。

服务器端程序肯定是要先接收消息的，所以我们使用recvfrom这个函数将接收到的信息存放在buffer这个缓冲区中，同时通过输出型参数 struct sockaddr_in peer 获取发送方的IP地址和端口号，如果接收消息成功，立马通过sendto函数将存放在buffer中的数据发送给对方，因为我们通过输出型参数获取到了发送方的网络信息，所以我们同样可以使用这个网络信息将数据发回给对方。

至此，服务器端的代码就编写完毕了。

客户端代码

当我们在启动客户端程序的时候，要使用这样的命令 ./udpclient 127.0.0.1 8888，这样的命令，其中127.0.0.1是服务器端的IP地址，8888是服务器端程序的端口号。Usage函数帮我们检查启动客户端程序的格式是否正确。

补充：127.0.0.1是本地环回IP，主要用于测试。
第一步：创建UDP socket。

客户端程序的第一步还是创建基于UDP协议通信的套接字，也就是创建自己用于该服务中进行网络通信的文件。创建的方式和服务器端一模一样。
第二步：绑定客户端的本地信息和网络信息。（特别注意）

客户端需不需要绑定客户端的本地信息和网络信息呢？答案是要，但是，不能够由我们开发人员在代码中手动的绑定，比如：你写的客户端程序绑定端口号为8888，我写的客户端程序也绑定端口号为8888，但是用户主机上的一个端口号只能唯一标识一个进程。所以客户端程序的端口号不能手动绑定，只能由用户主机上的操作系统自动分配。所以这一步我们什么也不需要做！
接下来的工作就和在服务器端程序中的差不多了，客户端程序也是在死循环中跑的，只能让用户手动的退出。客户端程序通过sendto接口向客户端发送数据，通过recvfrom接口接收客户端发过来的数据。

void Usage(std::string proc)
{
    std::cout << "Usage:\n\t" << proc << " serverip serverport\n"
              << std::endl;
}

// ./udpclient serverip serverport
int main(int argc, char *argv[])
{
    if (argc != 3)
    {
        Usage(argv[0]);
        exit(1);
    }
    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);

    // 1. 创建socket
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sockfd < 0)
    {
        std::cerr << "socket error" << std::endl;
    }

    // 构建目标主机的socket信息
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    server.sin_addr.s_addr = inet_addr(serverip.c_str());

    std::string message;
    // 2. 直接通信即可
    while(true)
    {
        std::cout << "Please Enter# ";
        std::getline(std::cin, message);
        sendto(sockfd, message.c_str(), message.size(), 0, (struct sockaddr*)&server, sizeof(server));

        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        char buffer[1024];
        ssize_t n = recvfrom(sockfd, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);
        if(n > 0)
        {
            buffer[n] = 0;
            std::cout << "server echo# " << buffer << std::endl;
        }
    }

    return 0;
}

至此，就可以完成客户端和服务器端的通信了。

3.程序拓展

我们写的服务器端代码中，接收到用户的信息之后，直接就返回相同的信息；那我们能不能改变服务器端的返回逻辑呢？针对客户端的不同信息，给客户响应不同的结果，这一点可以通过回调函数实现，读者可以自行拓展。

4.源代码附录

客户端代码

#include <iostream>
#include <string>
#include <cstring>
#include <cstdlib>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>

void Usage(std::string proc)
{
    std::cout << "Usage:\n\t" << proc << " serverip serverport\n"
              << std::endl;
}

int main(int argc, char *argv[])
{
    if (argc != 3)      
    {
        Usage(argv[0]);
        exit(1);
    }
    std::string serverip = argv[1];
    uint16_t serverport = std::stoi(argv[2]);

    // 1. 创建socket
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if(sockfd < 0)
    {
        std::cerr << "socket error" << std::endl;
    }

    // 构建目标主机的socket信息
    struct sockaddr_in server;
    memset(&server, 0, sizeof(server));
    server.sin_family = AF_INET;
    server.sin_port = htons(serverport);
    server.sin_addr.s_addr = inet_addr(serverip.c_str());

    std::string message;
    // 2. 直接通信即可
    while(true)
    {
        std::cout << "Please Enter# ";
        std::getline(std::cin, message);
        sendto(sockfd, message.c_str(), message.size(), 0, (struct sockaddr*)&server, sizeof(server));

        struct sockaddr_in peer;
        socklen_t len = sizeof(peer);
        char buffer[1024];
        ssize_t n = recvfrom(sockfd, buffer, sizeof(buffer)-1, 0, (struct sockaddr*)&peer, &len);
        if(n > 0)
        {
            buffer[n] = 0;
            std::cout << "server echo# " << buffer << std::endl;
        }
    }

    return 0;
}

服务器端代码

#pragma once

#include <iostream>
#include <string>
#include <cerrno>
#include <cstring>
#include <cstdlib>
#include <strings.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>

enum
{
    SOCKET_ERROR = 1,
    BIND_ERROR,
    USAGE_ERROR
};

const static int defaultfd = -1;

class UdpServer
{
public:
    UdpServer(uint16_t port) 
        : _sockfd(defaultfd)
        , _port(port)
        , _isrunning(false)
    {}
    void InitServer()
    {
        // 1. 创建udp socket 套接字 --- 必须要做的
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd < 0)
        {
            LOG(FATAL, "socket error, %s, %d\n", strerror(errno), errno);
            exit(SOCKET_ERROR);
        }
        LOG(INFO, "socket create success, sockfd: %d\n", _sockfd);

        // 2.0 填充sockaddr_in结构
        struct sockaddr_in local; // struct sockaddr_in 系统提供的数据类型。local是变量，用户栈上开辟空间。int a = 100; a = 20;
        bzero(&local, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_port = htons(_port); // port要经过网络传输给对面，先到网络，_port：主机序列-> 主机序列，转成网络序列
        // a. 字符串风格的点分十进制的IP地址转成 4 字节IP
        // b. 主机序列，转成网络序列
        // in_addr_t inet_addr(const char *cp) -> 同时完成 a & b
        // local.sin_addr.s_addr = inet_addr(_ip.c_str()); // "192.168.3.1" -> 字符串风格的点分十进制的IP地址 -> 4字节IP
        local.sin_addr.s_addr = INADDR_ANY; // htonl(INADDR_ANY);

        // 2.1 bind sockfd和网络信息(IP(?) + Port)
        int n = bind(_sockfd, (struct sockaddr *)&local, sizeof(local));
        if (n < 0)
        {
            LOG(FATAL, "bind error, %s, %d\n", strerror(errno), errno);
            exit(BIND_ERROR);
        }
        LOG(INFO, "socket bind success\n");
    }
    void Start()
    {
        while (true)
        {
            char buffer[1024];
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer); // 必须初始化成为sizeof(peer)
            // 1. 我们要让server先收数据
            ssize_t n = recvfrom(_sockfd, buffer, sizeof(buffer) - 1, 0, (struct sockaddr *)&peer, &len);
            if (n > 0)
            {
                buffer[n] = 0;
                LOG(DEBUG, "get message: %s\n",  buffer);
                // 2. 我们要将server收到的数据，发回给对方
                sendto(_sockfd, buffer, strlen(buffer), 0, (struct sockaddr *)&peer, len);
            }
        }
        _isrunning = false;
    }
    ~UdpServer()
    {}

private:
    int _sockfd;
    uint16_t _port;  // 服务器所用的端口号
};

服务端启动逻辑代码（main.cc）

#include <iostream>
#include <memory>
#include "UdpServer.hpp"

        
void Usage(std::string proc)
{
    std::cout << "Usage:\n\t" << proc << " local_port\n" << std::endl;
}

// ./udpserver port

int main(int argc, char *argv[])
{
    if(argc != 2)
    {
        Usage(argv[0]);
        exit(USAGE_ERROR);
    }

    uint16_t port = std::stoi(argv[1]);
    std::unique_ptr<UdpServer> usvr = std::make_unique<UdpServer>(port); 

    usvr->InitServer();
    
    usvr->Start();

    return 0;
}