1.端口号是传输层协议的内容。
2.进程间的通信有共享内存，消息队列等，以及套接字（跨网络）
3.一个端口号只能被一个进程占用。一个进程可以绑定多个端口号，但是一个端口号不能被多个进程同时绑定。
4.进程ID（PID）是用来标识系统内所有进程的唯一性的，它是属于系统级的概念；而端口号（port）是用来标识需要对外进行网络数据请求的进程的唯一性的，它是属于网络的概念。
底层可采用哈希的方式，建立了端口号和进程PID或PCB之间的映射关系

1.3TCP与UDP协议

TCP：要进行数据传输，二者要先进行连接

传输层协议
有连接的
可靠传输
面向字节流

UDP：进行数据传输时，不需要进行连接，发送数据即可，但无法确定数据的可靠性

传输层协议
无连接
不可靠传输
面向数据报

2.4网络字节序

大小端介绍
大端：高位存放在低地址，低位存放在高地址
小端：低位存放在低地址，高位存放在高地址
巧计：低低是小端

网络上的字节流内存一样，也有大小端之分。

TCP/IP协议规定，网络数据流采用 大端字节序，不管这台主机是大端机还是小端机, 都会按照这个TCP/IP规定的网络字节序来发送/接收数据。（ 发送数据时按内存地址从低到高的顺序发出，接受数据时是按内存地址从低到高的顺序保存）

使网络程序具有可移植性，调用以下库函数实现网络字节序和主机字节序之间的转换

#include <arpa inet.h>
uint32_t htonl(uint32_t hostlong);
uint16_t htons(uint16_t hostshort);
uint32_t ntohl(uint32_t netlong);
uint16_t ntohs(uint16_t netshort);</arpa>

h代表的是host，n代表的是network，s代表的是16位的短整型，l代表的是32位长整形
如果主机是小端字节序，函数会对参数进行处理，进行大小端转换
如果主机是大端字节序，函数不会对这些参数处理，直接返回

二.socket编程接口

2.1socket常见API

创建套接字：（TCP/UDP，客户端+服务器）

int socket(int domain, int type, int protocol);

绑定端口号：（TCP/UDP，服务器）

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

监听套接字 socket ：（TCP，服务器）

int listen(int sockfd, int backlog);

接收请求：（TCP，服务器）

int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);

建立连接：（TCP，客户端）

int connect(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

2.2sockaddr结构

其中struct sockaddr_in是用于网络通信，struct sockaddr_un是用于本地通信。sockaddr_in结构体存储了协议家族，端口号，IP等信息，网络通信时可以通过这个结构体把自己的信息发送给对方，也可以通过这个结构体获取对端的这些信息。

为了能让套接字的网络通信和本地通信能够使用同一套函数接口，于是出现了 sockeaddr结构体。其中这三个结构体的头部前16位是一样的，这个字段叫做协议家族。所以在用这个函数时可以统一传入sockeadder结构体，在设置参数时就可以通过设置协议家族这个字段，来表明我们是要进行网络通信还是本地通信。

补充内容：

1.IPv4和IPv6的地址格式定义在netinet/in.h中，IPv4地址用sockaddr_in结构体表示，包括16位地址类型，16位端口号和32位IP地址。
2.IPv4、IPv6地址类型分别定义为常数AF_INET、AF_INET6。这样，只要取得某种sockaddr结构体的首地址，不需要知道具体是哪种类型的sockaddr结构体，就可以根据地址类型字段确定结构体中的内容。
3.socket API可以都用struct sockaddr* 类型表示，在使用的时候需要强制转化成sockaddr_in；这样的好处是程序的通用性，可以接收IPv4、IPv6，以及UNIX Domain Socket各种类型的sockaddr结构体指针做为参数。

3.UDP网络程序

介绍：制作一个server服务端，用来提供各种服务。制作一个client客户端，可向服务端发送请求，服务端接受数据并处理后，再将数据返回给客户端。都将二者进行封装为一个类。

3.1服务端

3.1.1服务端创建套接字

创建套接字函数：

int socket(int domain, int type, int protocol);

参数解释：

domain：创建套接字的域或者叫做协议家族，也就是创建套接字的类型。该参数就相当于struct sockaddr结构的前16个位。如果是本地通信就设置为AF_UNIX，如果是网络通信就设置为AF_INET（IPv4）或AF_INET6（IPv6）。
type：创建套接字时所需的服务类型。其中最常见的服务类型是SOCK_STREAM和SOCK_DGRAM，如果是UDP的网络通信，就填入SOCK_DGRAM，叫做用户数据报服务。如果是TCP的网络通信，就填入SOCK_STREAM，叫做流式套接字，提供的是流式服务。
protocol：创建套接字的协议类别。你可以指明为TCP或UDP。设置为0表示的就是默认，就会根据前两个参数自动推导出协议类型。

返回值：创建成功返回文件描述符，失败返回-1。

代码：

class UdpServer
{
public:
    void init()  //初始化
    {
        sockfd_ = socket(AF_INET, SOCK_DGRAM, 0); // 创建套接字
        std::cout << "创建套接字成功" << sockfd_ << std::endl;
        if (sockfd_ < 0)
        {
            cerr<< "socket error" << endl;
            exit(-1);
        }
    }

private:
    int sockfd_;     // 文件描述符
};

补充内容：

1.我们是在应用层编写代码，其我们调用的实际是下三层的接口，而传输层和网络层都是在操作系统内完成的，我们在应用层调用的接口都是系统接口。
2.进程调用socket函数，会创建一个相对应文件结构体，同样是在当前进程的 task_struct 中的所指向的一个指针数组里填入那个文件结构体地址，建立关联，后将那个指针数组下标返回，就是文件描述符。
3.每一个文件结构体中包含的就是对应打开文件各种信息，比如文件的属性信息、操作方法以及文件缓冲区等，但对于打开的”网络文件”来说，这里的文件缓冲区对应的是网卡。

3.1.2绑定服务端

当套接字创建成功后，对应的文件就被创建且已被当前进程管理了，当该文件实际还未与网络真正相关联起来。

bind函数：

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

参数解释：

sockfd：绑定的文件的文件描述符。也就是我们创建套接字时获取到的文件描述符。
addr：网络相关的属性信息，包括协议家族、IP地址、端口号等。
addrlen：传入的addr结构体的长度。

返回值：绑定成功返回0，绑定失败返回-1。

详细介绍struct sockaddr_in结构体：

sin_family：表示协议家族。
sin_port：表示端口号，是一个16位的整数。
sin_addr：表示IP地址，是一个32位的整数。
sin_addr的类型是 struct in_addr，其实该结构体当中就只有一个成员，该成员就是一个32位的整数，IP地址实际就是存储在这个整数当中的

如何去理解绑定？

绑定就是将IP地址和端口号对应的网络文件建立关联，可以改变网络文件当中文件操作函数的指向，将对应的操作函数改为对应网卡的操作方法。

可在构造函数时将IP与端口号就初始化，

代码：

class UdpServer
{
public:
    UdpServer(int port, std::string ip = "")
        : ip_(ip), port_(port)
    {
    }
    void init()
    {
        sockfd_ = socket(AF_INET, SOCK_DGRAM, 0); // 创建套接字
        std::cout << "创建套接字成功" << sockfd_ << std::endl;
        if (sockfd_ < 0)
        {
            exit(-1);
        }
        struct sockaddr_in local;
        bzero(&local, sizeof(sockaddr)); //将该结构体内容清空

        local.sin_family = AF_INET;      //进行填充
        local.sin_port = htons(port_);   //主机转网络
        local.sin_addr.s_addr = inet_addr(ip_.c_str());            // 会自动进行h->n转换
        int k = bind(sockfd_, (const struct sockaddr *)&local, sizeof(local)); // 绑定
        if (k == -1)
        {
            exit(-2);
        }
        std::cout << "绑定成功" << k << std::endl;
    }
private:
    int sockfd_;     // 文件描述符
    int port_;       // 端口号
    std::string ip_; // IP地址
};

详细介绍字符串IP与整数IP：

字符串IP：127.239.231.987 这种形式，也做基于字符串的点分十进制IP地址。

整数IP：IP地址在进行网络传输时所用的形式，用一个32位的整数来表示IP地址。

为何需要进行IP类型的转换？

若以字符串IP进行数据的发送，则需要15个字节的大小。若把字符串ip分为4部分，每个部分都是0-255，这只需要8个比特位，4部分就是32个比特位，也就是4字节。

如何进行转换？

可以运用位段的方式，2个变量共享一块空间。在一个结构体中定义一个32位比特位的整数，再定义一个结构体，运用位段的方式，如：

操作系统也提供了几个IP类型转换的函数:

3.1.3recvfrom

用来获取客户端发送的数据

参数解释：

ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags, struct sockaddr *src_addr, socklen_t *addrlen);

参数解释：

sockfd:从该套接字获取信息
buf:缓冲区，把数据读取到该缓冲区中
len:一次读多少数据
flags:表示阻塞读取，一般写0
src_addr:一个输出型参数，获取到对端的信息，有端口号，IP等，方便后序我们对其进行响应
addrlen:输入输出型参数，传入一个想要读取对端src_addr的长度，最后返回实际读到的长度

补充：

recvfrom函数提供的参数是 struct sockaddr*类型的，因此我们在传入结构体地址时需要将 struct sockaddr_in*类型进行强转。

代码：

  void start()
    {
        while (true)
        {
            char inbuffer[1024];
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            ssize_t size = recvfrom(sockfd_, inbuffer, sizeof(inbuffer) - 1, 0, (struct
            sockaddr *)&peer, &len);

            if (size > 0)
            {
                inbuffer[size] = '\0';
                int port = ntohs(peer.sin_port);
                std::string ip = inet_ntoa(peer.sin_addr);
                std::cout << ip << ":" << port << "# " << inbuffer << std::endl;
            }
            else
            {
                std::cerr << "recvfrom error" << std::endl;
            }

        }
    }

3.2客户端

3.2.1客户端创建套接字

class Upclient
{
public:
    Upclient(std::string ip, int port)
        : ip_(ip), port_(port)
    {
    }

    void init()
    {
        sockfd_ = socket(AF_INET, SOCK_DGRAM, 0); // 创建套接字
        if (sockfd_ < 0)
        {
            exit(-1);
        }
        std::cout << "创建套接字成功" << sockfd_ << std::endl;
    }
private:
    int sockfd_;     // 文件描述符
    int port_;       // 端口号
    std::string ip_; // IP地址
};

3.2.2客户端绑定

服务端是给别人提供服务的，当服务器启动后，许多的客户端就可以通过IP与端口号去找到对应服务端的那个进程，且服务端一直都在运行，随时可以被连接，所以IP与端口号不能随意改变。
客户端的端口号是不需要自己主动去绑定的，客户端可以随时退出，若绑定了一个端口，那么这个端口号就只能属于一个进程用，其它客户端就不能使用这个端口号了，其实用sendto这样的接口时，操作系统会自动给当前客户端获取一个唯一的端口号，不能自己主动去绑定。

3.2.3sendto

用来向服务端发送请求

sendto函数：

ssize_t sendto(int sockfd, const void *buf, size_t len, int flags, const struct sockaddr *dest_addr, socklen_t addrlen);

参数解释：

sockfd：对应操作的文件描述符。表示将数据写入该文件描述符索引的文件当中。
buf：待写入数据的存放位置。
len：待写入数据的字节数。
flags：写入的方式，一般设置为0，默认阻塞写入。
dest_addr：对端网络相关的属性信息，包括协议家族、IP地址、端口号等。
addrlen：传入dest_addr结构体的长度。

返回值说明：成功返回实际写入的字节数，写入失败返回-1

补充：由于sendto函数提供的参数也是 struct sockaddr*类型的，在传入结构体地址时需要将 struct sockaddr_in*类型进行强转

代码：

    void strat()
    {
        struct sockaddr_in server;//填入对端网络信息
        bzero(&server, sizeof server);
        server.sin_family = AF_INET;
        server.sin_port = htons(port_);
        server.sin_addr.s_addr = inet_addr(ip_.c_str());

        std::string buffer;
        while (true)
        {
            std::cerr << "Please Enter# ";
            std::getline(std::cin, buffer);
            sendto(sockfd_, buffer.c_str(), buffer.size(), 0,
                   (const struct sockaddr *)&server, sizeof(server)); // 首次调用sendto函
                                          //数的时候，我们的client会自动bind自己的ip和port
        }
    }

3.3引入命令行参数

先把服务端与客户端完善。

服务端：


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

    if (argc != 2)
    {
        std::cerr << "Usage: " << argv[0] << " port" << std::endl;
        return 1;
    }
    std::string ip = "127.0.0.1"; // 本地环回
    int port = atoi(argv[1]);
    UdpServer *p = new UdpServer(port, ip);
    p->init();
    p->start();
    return 0;
}

客户端：

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

    if (argc != 3)
    {
        std::cerr << "Usage: " << argv[1] << "ip" << argv[2] << "port" << std::endl;
        return 1;
    }
    std::string server_ip = argv[1];
    uint16_t server_port = atoi(argv[2]);
    Upclient *c = new Upclient(server_ip, server_port);
    c->init();
    c->strat();
    return 0;
}

结果：

3.4多人网络聊天制作

介绍：按照前面的介绍，现在客户端可以向服务端发送数据，服务端也可以接受到数据。

改进：当客户端向服务端发送数据时，服务端把相关的客户端记录下来，并把收到的消息发给所有的客户端。同时，客户端也要可以接受服务端发送来的消息。这样就完成了一个多人聊天室。

3.4.1客户端

运行时创建一个线程，让这个线程去接受服务端发送的数据，主线程可继续向服务端发送数据。

 static void *_recvfrom(void *args)
    {
        while (true)
        {
            Upclient *up = (Upclient *)args;
            char inbuffer[1024];
            struct sockaddr_in tmp;
            socklen_t leng = sizeof(tmp);
            ssize_t size = recvfrom(up->sockfd_, inbuffer, sizeof(inbuffer) - 1, 0,
           (struct sockaddr *)&tmp, &leng);
            inbuffer[size]='\0';
            std::cout << " " << inbuffer << std::endl;
        }
    }
    void strat()
    {
        struct sockaddr_in server;
        bzero(&server, sizeof server);
        server.sin_family = AF_INET;
        server.sin_port = htons(port_);
        server.sin_addr.s_addr = inet_addr(ip_.c_str());

        std::string buffer;
        while (true)
        {
            std::cerr << "Please Enter# ";
            std::getline(std::cin, buffer);
            // 发送消息给server
            sendto(sockfd_, buffer.c_str(), buffer.size(), 0,
                   (const struct sockaddr *)&server, sizeof(server)); // 首次调用sendto函
                                            //数的时候，我们的client会自动bind自己的ip和port
            pthread_t tid;
            pthread_create(&tid, nullptr, _recvfrom, (void *)this);
         }
    }

3.4.2服务端

添加 std::unordered_map

 void start()
    {
        while (true)
        {
            char inbuffer[1024];
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            ssize_t size = recvfrom(sockfd_, inbuffer, sizeof(inbuffer) - 1, 0, (struct sockaddr *)&peer, &len);

            if (size > 0)
            {
                inbuffer[size] = '\0';
                int port = ntohs(peer.sin_port);
                std::string ip = inet_ntoa(peer.sin_addr);
                std::cout << ip << ":" << port << "# " << inbuffer << std::endl;
                checkonline(ip, port, peer);  //记录所有
                sendmessage(ip,port,inbuffer);
            }
            else
            {
                std::cerr << "recvfrom error" << std::endl;
            }

        }
    }
    void checkonline(std::string ip, uint32_t port, struct sockaddr_in peer)
    {
        std::string key = ip;
        key += ":";
        key += std::to_string(port);
        auto iter = users.find(key);
        if (iter == users.end())
        {
            users.insert({key, peer});
        }
    }
    void sendmessage(std::string ip, uint32_t port, std::string messgae)
    {
        std::string str(ip);
        str += " ";
        str += std::to_string(port);
        str += " ";
        str += messgae;

        for (auto T : users)
        {
            sendto(sockfd_, str.c_str(), str.size(), 0, (const struct sockaddr *)&(T.second), sizeof(T.second));
        }
    }

结果：输出结果有点乱，可以把一个客户端收到的消息重定向到另一个文件中，这里不再演示。

3.5完整代码：

服务端：

class UdpServer
{
public:
    UdpServer(int port, std::string ip = "")
        : ip_(ip), port_(port)
    {
    }
    void init()
    {
        sockfd_ = socket(AF_INET, SOCK_DGRAM, 0); // 创建套接字
        std::cout << "创建套接字成功" << sockfd_ << std::endl;
        if (sockfd_ < 0)
        {
            exit(-1);
        }
        struct sockaddr_in local;
        bzero(&local, sizeof(sockaddr));
        local.sin_family = AF_INET;
        local.sin_port = htons(port_);
        local.sin_addr.s_addr = inet_addr(ip_.c_str());                        // 会自动进行h->n转换
        int k = bind(sockfd_, (const struct sockaddr *)&local, sizeof(local)); // 绑定
        if (k == -1)
        {
            exit(-2);
        }
        std::cout << "绑定成功" << k << std::endl;
    }

    void start()
    {
        while (true)
        {
            char inbuffer[1024];
            struct sockaddr_in peer;
            socklen_t len = sizeof(peer);
            ssize_t size = recvfrom(sockfd_, inbuffer, sizeof(inbuffer) - 1, 0, (struct sockaddr *)&peer, &len);

            if (size > 0)
            {
                inbuffer[size] = '\0';
                int port = ntohs(peer.sin_port);
                std::string ip = inet_ntoa(peer.sin_addr);
                std::cout << ip << ":" << port << "# " << inbuffer << std::endl;
                checkonline(ip, port, peer);
                sendmessage(ip,port,inbuffer);
            }
            else
            {
                std::cerr << "recvfrom error" << std::endl;
            }

        }
    }
    void checkonline(std::string ip, uint32_t port, struct sockaddr_in peer)
    {
        std::string key = ip;
        key += ":";
        key += std::to_string(port);
        auto iter = users.find(key);
        if (iter == users.end())
        {
            users.insert({key, peer});
        }
        else
        {
        }
    }
    void sendmessage(std::string ip, uint32_t port, char message[])
    {
        std::string str(ip);
        str += " ";
        str += std::to_string(port);
        str += " ";
        str += message;

        for (auto T : users)
        {
            sendto(sockfd_, str.c_str(), str.size(), 0, (const struct sockaddr *)&(T.second), sizeof(T.second));
        }
    }

private:
    int sockfd_;     // 文件描述符
    int port_;       // 端口号
    std::string ip_; // IP地址
    std::unordered_map users;
};

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

    if (argc != 2)
    {
        std::cerr << "Usage: " << argv[0] << " port" << std::endl;
        return 1;
    }
    std::string ip = "127.0.0.1"; // 本地环回
    int port = atoi(argv[1]);
    UdpServer *p = new UdpServer(port, ip);
    p->init();
    p->start();
    return 0;
}

客户端：

class Upclient
{
public:
    Upclient(std::string ip, int port)
        : ip_(ip), port_(port)
    {
    }

    void init()
    {
        sockfd_ = socket(AF_INET, SOCK_DGRAM, 0); // 创建套接字
        std::cout << "创建套接字成功" << sockfd_ << std::endl;
        if (sockfd_ < 0)
        {
            exit(-1);
        }
    }

    static void *_recvfrom(void *args)
    {
        while (true)
        {
            Upclient *up = (Upclient *)args;
            char inbuffer[1024];
            struct sockaddr_in tmp;
            socklen_t leng = sizeof(tmp);
            ssize_t size = recvfrom(up->sockfd_, inbuffer, sizeof(inbuffer) - 1, 0, (struct sockaddr *)&tmp, &leng);
            inbuffer[size]='\0';
            std::cout << " " << inbuffer << std::endl;
        }
    }
    void strat()
    {
        struct sockaddr_in server;
        bzero(&server, sizeof server);
        server.sin_family = AF_INET;
        server.sin_port = htons(port_);
        server.sin_addr.s_addr = inet_addr(ip_.c_str());

        std::string buffer;
        while (true)
        {
            std::cerr << "Please Enter# ";
            std::getline(std::cin, buffer);
            // 发送消息给server
            sendto(sockfd_, buffer.c_str(), buffer.size(), 0,
                   (const struct sockaddr *)&server, sizeof(server)); // 首次调用sendto函数的时候，我们的client会自动bind自己的ip和port
            pthread_t tid;
            pthread_create(&tid, nullptr, _recvfrom, (void *)this);
        }
    }

private:
    int sockfd_;     // 文件描述符
    int port_;       // 端口号
    std::string ip_; // IP地址
};

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

    if (argc != 3)
    {
        std::cerr << "Usage: " << argv[1] << "ip" << argv[2] << "port" << std::endl;
        return 1;
    }
    std::string server_ip = argv[1];
    uint16_t server_port = atoi(argv[2]);
    Upclient *c = new Upclient(server_ip, server_port);
    c->init();
    c->strat();
    return 0;
}

Original: https://blog.csdn.net/m0_64397669/article/details/128366737
Author: 派派
Title: UDP通信

原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/788110/

转载文章受原作者版权保护。转载请注明原作者出处！

python

【自取】最近整理的，有需要可以领取学习：

Linux核心资料大放送~

全栈面试题汇总（持续更新&可下载）

一个提高学习100%效率的工具！

【超详细】深度学习面试题目！

LeetCode Python刷题答案下载！

LeetCode Java版刷题答案下载！

LeetCode C++ 版本，抓紧保存！

LeetCode GO语言刷题答案下载！

seaborn简明教程（一）

1. Seaborn简介 seaborn是基于 matplotlib的数据可视化库。它在 matplotlib的基础上，进行了更高级的API封装，从而使得绘图更加容易，不需要经过大…

Python 2023年9月5日
0050
面试官：什么是伪共享，如何避免？

theme: jzman 本文已收录到GitHub · AndroidFamily ，有 Android 进阶知识体系，欢迎 Star。技术和职场问题，请关注公众号 [彭旭锐] 私…

Python 2023年10月14日
0058
ORM之聚合查询，分组查询，F查询，Q查询，ORM查询优化，事务操作，常见字段及参数，多对多三种表的创建

1.查询主键为1的书籍对应的出版社名称和书名 models.Publish.objects.filter(book__pk=1).values(‘name’,’book__titl…

Python 2023年8月5日
0071
ubuntu20.04安装cuda版本问题 + 系统cuda与conda虚拟cuda的差别

在ubuntu 20.04版本的服务器上，配置cuda与pytorch使用gpu版本加速踩坑流程：ubuntu20.04最低支持cuda11.0—-降gcc版本安装c…

Python 2023年9月8日
00144
python深度学习基于pytorch代码1.3Numpy的算术运算

### 回答1： PyTorch_是一个用于 _深度学习_的开源 _Python_库，它是一种动态计算图框架，可以使模型的训练更加灵活。它提供了大量的高级功能，如自动微分、动态图构…

Python 2023年8月25日
0050
python3 flask 编写上传文件接口

Python 2023年5月24日
0064
echarts-python数据可视化大屏展示

echarts-数据可视化大屏展示python-pandas-echarts-flask 新手入门，还请指教。文章目录 1 数据预处理 2可视化部分 * 2.1query.py …

Python 2023年8月11日
0055
36、Java——一个案例学会三层架构对数据表的增删改查

✅作者简介：热爱国学的Java后端开发者，修心和技术同步精进。🍎个人主页：Java Fans的博客🍊个人信条：不迁怒，不贰过。小知识，大智慧。💞当前专栏：Java案例分享专栏✨特色…

Python 2023年9月27日
0047
pandas模块总结一

pandas模块 1. 基本概念 2. Series的基本操作 * 2.1 Series的创建方法 2.2 获取Series中数据的index、values 2.3 Series的…

Python 2023年8月8日
0060
pandas concat “InvalidIndexError: Reindexing only valid with uniquely valued Index objects“

利用pandas的concat方法可以对多个DataFrame进行快捷的堆叠，非常方便，但是在使用concat会出现”pandas.errors.InvalidInde…

Python 2023年8月6日
0057
[Go疑难杂症]为什么nil不等于nil

现象在日常开发中，可能一不小心就会掉进 Go 语言的某些陷阱里，而本文要介绍的 nil ≠ nil 问题，便是其中一个，初看起来会让人觉得很诡异，摸不着头脑…

Python 2023年10月17日
0051
【机器学习】K-means算法Python实现教程

阅读须知：阅读本文需要有一定的Python及Numpy基础本文将介绍： K-means算法实现步骤使用Python实现K-means算法借助Numpy的向量计算提升计算速度…

Python 2023年8月2日
0074
【机器学习】李宏毅——Adversarial Attack（对抗攻击）

研究这个方向的动机，是因为在将神经网络模型应用于实际场景时，它仅仅拥有较高的正确率是不够的，例如在异常检测中、垃圾邮件分类等等场景，那些负类样本也会想尽办法来”欺骗&#…

Python 2023年10月24日
0075
自动化测试之 pytest 的使用03

自动化测试之 pytest 的使用03 * – 1.6 使用parametrize实现参数化 – 1.7 多次使用parametrize – 1…

Python 2023年9月13日
0048
《使用pycharm把本地pyhton项目实时同步至服务器》详细操作

各位大家好，相信大家在做python开发的时候，常常会因《本地项目已完成，怎样完全同步至服务器呢》的困扰，我们完全可以通过pycharm的一些配置来做到。服务器：centos7本地…

Python 2023年8月5日
0061
盘点典型错误之TypeError: X() got multiple values for argument ‘Y‘

个性签名：整个建筑最重要的是地基，地基不稳，地动山摇。而学技术更要扎稳基础，关注我，带你稳扎每一板块邻域的基础。博客主页：七归的博客南来的北往的，走过路过千万别错过，错过本篇，&#…

Python 2023年8月2日
0068

2024 年 5 月
一	二	三	四	五	六	日
		1	2	3	4	5
6	7	8	9	10	11	12
13	14	15	16	17	18	19
20	21	22	23	24	25	26
27	28	29	30	31

UDP通信

一.预备知识

1.1IP与MAC

1.2端口号

1.3TCP与UDP协议

2.4网络字节序

二.socket编程接口

2.1socket常见API

2.2sockaddr结构

3.UDP网络程序

3.1服务端

3.1.1服务端创建套接字

3.1.2绑定服务端

3.1.3recvfrom

3.2客户端

3.2.1客户端创建套接字

3.2.2客户端绑定

3.2.3sendto

3.3引入命令行参数

3.4多人网络聊天制作

3.4.1客户端

3.4.2服务端

3.5完整代码：

大家都在看