46 udp网络程序

查询网络服务的命令

netstat -nlup
n: 显示数字
a：显示所有
u：udp服务
p：显示pid

在这里插入图片描述
Recv-Q收到的数量，本地ip和远端ip，00表示可以收到任何地址

网络聊天

服务端

定义一个server类，成员保存ip地址，端口号，文件描述符，是否运行
在这里插入图片描述
ip和端口号构造时设置默认值，“0.0.0.0”和“8000”
在这里插入图片描述

  • init函数内初始化套接字，返回文件描述符，然后绑定到os。
    在这里插入图片描述
    socket的三个参数，协议族IPv4，套接字类型面向字节流，协议0自动选择，面向字节流默认匹配udp
    返回值描述符，是后续功能传入的第一个参数

  • bind函数建立本地捆绑
    在这里插入图片描述
    第二个参数需要sockaddr类型，这个通用类型需要用sockaddr_in类型强转
    在这里插入图片描述

设置sockaddr_in的结构内容：
初始化为0
设置协议族
ip地址，需要将点分十进制转换为32位整数类型uint32_t，然后转为网络字节序
端口转为网络字节序

ip地址转化方法
在这里插入图片描述
先定义ip结构体，每个成员8位，总共4字节
字符串转整数：
1.先去掉.符号，切割为四个整数
2.然后定义一个uint32变量，强转为ip结构体
3.每个部分对应分割的字符串，将字符串转整数

整数转字符串：
1.强制转换为ip结构
2.将每部分转为字符串加上.拼接为点分

  • run函数内接收和发送消息

在这里插入图片描述在这里插入图片描述

rev第一个参数标识符，第二个接收存放的缓冲区，缓冲区大小，调用方式，0表示阻塞直到有数据或错误，对方的协议结构，协议结构的长度（socklen_t类型）
send参数，标识符，发送内容，内容的大小，调用方式0，不使用特殊行为，对方的协议结构，协议的长度

启动服务端查看有没有服务
在这里插入图片描述

ip和port说明
ip可以固定设置，如果是本机ip，虚拟机是可以的，云服务器禁止绑定公网ip。ip填0的意思是，凡是发给我主机的数据，都根据端口号向上交付，如果有两张网卡，固定设置，只会收到发往一个的，0可以收到任一个网卡的，可以提前设置ip，也可以在绑定时设置

addrin.sin_addr.s_addr = INADDR_ANY;

【0,1023】是系统内定的端口号，有固定的应用层协议使用，http：80 https：443 mysql：3306。。也有几个这种特殊的，所以设置端口号时尽量往大一点设置

全

#pragma once
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include "log.hpp"

enum
{
    SOCK_ERR = 1
};

uint16_t defaultport = 8000;
std::string defaultip = "0.0.0.0";

Log log;
class server
{ 
public:
    server(const std::string ip = defaultip, const uint16_t port = defaultport)
    {
        _ip = ip;
        _port = port;
        _sockfd = 0;
    }

    void init()
    {
        //1.创建套接字
        int _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd < 0)
        {
            log.logmessage(fatal, "socket create error:%d", _sockfd);
            exit(SOCK_ERR);
        }

        log.logmessage(info, "socket create success:%d", _sockfd);

        //绑定
        sockaddr_in addrin;
        bzero(&addrin, sizeof(addrin));
        addrin.sin_family = AF_INET;
        addrin.sin_addr.s_addr = htonl(inet_addr(_ip.c_str()));
        addrin.sin_port = htons(_port);
        addrin.sin_addr.s_addr = INADDR_ANY;

        int ret = bind(_sockfd, (const sockaddr*)&addrin, sizeof(addrin));
        if (ret < 0)
        {
            log.logmessage(fatal, "bind error:%s", strerror(errno));
        }
        log.logmessage(info, "bind success:%d", ret);

    }

    void run()
    {
        _isrunning = true;
        char buff[1024];
        while (_isrunning)
        {
            sockaddr client;
            socklen_t len = sizeof(client);
            ssize_t n = recvfrom(_sockfd, buff, sizeof(buff) - 1, 0, &client, &len);
            if (n < 0)
            {
                //log.logmessage(warning, "recv error:%s", strerror(errno));
            }

            buff[1024] = 0;
            std::string echo_string = buff;
            echo_string = "client#" + echo_string;
            sendto(_sockfd, echo_string.c_str(), echo_string.size(), 0, &client, len);
        }
    }
 
    ~server()
    {
        if (_sockfd > 0)
            close(_sockfd);
    }

private:
    int _sockfd;      // 网路文件描述符
    uint16_t _port;   // 任意地址bind 0
    std::string _ip;  // 表明服务器进程的端口号
    bool _isrunning;
};

客户端

先初始化端口和ip，这个安装软件使用的时候已经默认设好了。这里定为服务器的ip和刚刚启动服务的端口
在这里插入图片描述
设置目标协议addr结构，内容为上面初始化
在这里插入图片描述

打开套接字
在这里插入图片描述

客户端也是需要绑定的，只不过不是用户显示绑定，由os随机选择，一个端口号只能被一个进程绑定，对服务端也是如此。客户端的port只需要保证主机上的唯一性，在首次发送数据的时候会自动绑定

和服务端一样，发送和接受消息，只不过客户端先发送再接收
在这里插入图片描述
全

#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <unistd.h>
#include <strings.h>

using namespace std;
int main()
{

    uint16_t port = 8000;
    string ip = "106.54.46.147";
    sockaddr_in in;
    bzero(&in, sizeof(in));
    in.sin_family = AF_INET;
    in.sin_addr.s_addr = inet_addr(ip.c_str());
    in.sin_port = htons(port);
    int sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (sockfd < 0)
    {
        cout << "socket error" << endl;
    }

    //client 需要绑定，但不显示绑定，由os自由选择

    string message;
    char buff[1024];
    while (true)
    {
        cout << "please enter: ";
        getline(cin , message);

        sendto(sockfd, message.c_str(), message.size(), 0, (const sockaddr*)&in, sizeof(in));
        sockaddr_in rec;
        socklen_t len = sizeof(rec);
        ssize_t s = recvfrom(sockfd, buff, sizeof(buff) - 1, 0, (sockaddr*)&rec, &len);
        if (s > 0)
        {
            buff[s] = 0;
            cout << buff << endl;
        }
    }

    close(sockfd);
}

注意
hton转字节序的函数是根据本机字节序情况转换，如果本机是小端调用几次会转几次

打开云主机端口
如果程序没问题，但收发不到消息，可以试着打开云主机的防火墙端口，以腾讯云为例：
登录控制台，查看详情，防火墙添加规则
在这里插入图片描述

服务端自定义数据处理
使用自定义函数类型，run调用实例出的函数，实现数据处理方法的自定义

using func_t = std::function<std::string(const std::string &)>; //定义函数类型

std::string handler(const std::string& str)
{
    std::string s = "server get message: ";
    s += str;
    std::cout << s << std::endl;
    return s;
}

命令bash

服务端可以收到信息了，也可以将收到的内容当做其他形式。如果将收到的内容当做xshell命令，就会执行命令
run执行的函数替换。popen函数可以创建子进程通信管道，将传入的命令创建子进程执行。将命令执行的结果添加到字符串内，回显发送给客户端

std::string execute(const std::string& cmd)
{
    //safecheck 不想执行的命令安全检查
    FILE* fp = popen(cmd.c_str(), "r");
    if (fp == nullptr)
    {
        perror("popen");
        return "error";
    }

    string ret;
    char buff[4096];
    while (true)
    {
        char *ok = fgets(buff, sizeof(buff), fp);
        if (ok == nullptr)
        {
            break;
        }

        ret += buff;
    }

    pclose(fp);
    return ret;
}

在这里插入图片描述

本地环回地址

只会在本地协议走一遍，不会发向网络，通常用来测试

xshell

这就是为什么要用xshell登录，就相当于客户端，将命令发到了远端的服务器，接受到字符串执行命令，然后将结果发送回xshell显示

后台里有一个ssh的tcp服务，端口号22号接收发送的命令
在这里插入图片描述

win客户端

实现让win客户端和linux服务端网络通讯
win需要包含头文件WinSock2.h头文件和ws2_32.lib网络库
上面的头文件要在windows.h这个头文件之前，不然会报错

在这里插入图片描述

首先初始化网络版本信息，addr协议内容
在这里插入图片描述
打开套接字
在这里插入图片描述

收发功能和前面一样
在这里插入图片描述
清理数据
在这里插入图片描述
在这里插入图片描述
两边汉字编码不一样，可能会显示有问题

全

#include <iostream>
#include <string>
#include <WinSock2.h>
//#include <Windows.h>

//关闭安全警告
#pragma warning(disable:4996)
//包含网络库
#pragma comment(lib, "ws2_32.lib")

using namespace std;
string ip = "106.54.46.147";
uint16_t port = 8000;

int main()
{
	//初始化socket数据
	WSADATA wsd;
	WSAStartup(MAKEWORD(2, 2), &wsd);

	sockaddr_in server;
	memset(&server, 0, sizeof(server));
	server.sin_family = AF_INET;
	server.sin_addr.S_un.S_addr = inet_addr(ip.c_str());
	server.sin_port = htons(port);

	//套接字
	SOCKET sockfd = socket(AF_INET, SOCK_DGRAM, 0);
	if (sockfd == SOCKET_ERROR)
	{
		cout << "sock error" << endl;
		return 1;
	}

	string message;
	char buff[1024];
	while (true)
	{
		cout << "please enter: ";
		getline(cin, message);

		sendto(sockfd, message.c_str(), message.size(), 0, (const sockaddr*) & server, sizeof(server));
		sockaddr_in temp;
		int len = sizeof(temp);
		int s = recvfrom(sockfd, buff, 1023, 0, (sockaddr*)&temp, &len);
		if (s > 0)
		{
			buff[s] = 0;
			cout << buff << endl;
		}
	}

	closesocket(sockfd);
	WSACleanup();
	return 0;
}

网络聊天室 (多线程)

聊天室功能需要用户名标识每一个主机，这里用对方的ip和port作为区分，发言的前缀
用一个无序map容器，string作为索引，值存addr结构
在这里插入图片描述

将收到的addr结构转为主机序列加入到显示屏幕的内容

在这里插入图片描述
在这里插入图片描述

检查如果是新的主机就加入到_online结构，并显示新主机加入
在这里插入图片描述
遍历容器内容，将最新消息发送给所有用户
在这里插入图片描述
sendto可以自动转网络序列，所以容器内容不需要转换

上面可以实现接收到不同用户的消息，但有个问题，客户端的getline没有内容时是一直阻塞住的，不输入内容的时候收不到其他消息。所以用多线程，一个线程收消息，一个线程发消息

两个线程都需要文件描述符和addr结构
定义一个结构体，将初始化的内容赋值给结构体在这里插入图片描述

在这里插入图片描述
这时可以显示其他人的消息，但自己因为发送和接收的顺序无法正常接收。需要将输入和输出的终端分开

在这里插入图片描述

/dev/pts 这个文件里保存了所有打开的终端

在这里插入图片描述

0号终端重定向到6，显示到了1号页面中，所以文件6代表了下面这个终端，5是上面的终端。在接收消息后想显示到上面的终端，下面的用来发送，由于线程的文件描述共享，所以将标准错误重定向到5，在下面打开服务端

在这里插入图片描述

上面的内容可以简化，打开两个端口，提前确定哪个用来显示，另一个启动客户端，将标准错误重定向到显示端
在这里插入图片描述
全
服务端

#pragma once
#include <string>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <functional>
#include <unordered_map>
#include "log.hpp"

enum
{
    SOCK_ERR = 1
};

uint16_t defaultport = 8000;
std::string defaultip = "0.0.0.0";
using func_t = std::function<std::string(const std::string &)>; //定义函数类型
//typedef std::function<std::string(const std::string &)> func_t

Log log;
class server
{ 
public:
    server(const std::string ip = defaultip, const uint16_t port = defaultport)
    {
        _ip = ip;
        _port = port;
        _sockfd = 0;
    }

    void init()
    {
        //1.创建套接字
        _sockfd = socket(AF_INET, SOCK_DGRAM, 0);
        if (_sockfd < 0)
        {
            log.logmessage(fatal, "socket create error:%d", _sockfd);
            exit(SOCK_ERR);
        }

        log.logmessage(info, "socket create success:%d", _sockfd);

        //绑定
        struct sockaddr_in local;
        bzero(&local, sizeof(local));
        local.sin_family = AF_INET;
        local.sin_addr.s_addr = inet_addr(_ip.c_str());
        local.sin_port = htons(_port);
        //local.sin_addr.s_addr = INADDR_ANY;

        int ret = bind(_sockfd, (const sockaddr*)&local, sizeof(local));
        if (ret < 0)
        {
            log.logmessage(fatal, "bind error:%s", strerror(errno));
        }
        log.logmessage(info, "bind success:%d", ret);

    }

    void checkuser(const struct sockaddr_in& sock, const string ip, const uint16_t port)
    {
        auto it = _online.find(ip);
        if (it == _online.end())
        {
            _online.insert({ip, sock});
            cout << "[" << ip << ":" << port << "] add new user" << endl;
        }
    }

    void broadcast(const string& message, string ip, uint16_t port)
    {
        for (const auto user : _online)
        {
            socklen_t len = sizeof(user.second);
            sendto(_sockfd, message.c_str(), message.size(), 0, (struct sockaddr*)(&user.second), len);
        }
    }

    void run(func_t func)
    {
        _isrunning = true;
        char buff[1024];
        while (_isrunning)
        {
            sockaddr_in client;
            socklen_t len = sizeof(client);
            ssize_t n = recvfrom(_sockfd, buff, sizeof(buff) - 1, 0, (sockaddr*)&client, &len);
            if (n < 0)
            {
                //log.logmessage(warning, "recv error:%s", strerror(errno));
                continue;
            }

            buff[n] = 0;
            //获取端口号和ip
            string ip = inet_ntoa(client.sin_addr);
            // 网络字节序转主机
            uint16_t port = ntohs(client.sin_port);

            checkuser(client, ip, port);
            std::string echo_string = "[" + ip + ":" + to_string(port) + "]: " + buff;
            broadcast(echo_string, ip, port);
            // std::cout << echo_string << endl;
            //  echo_string = func(echo_string);
            //sendto(_sockfd, echo_string.c_str(), echo_string.size(), 0, (const sockaddr *)&client, len);
        }
    }
 
    ~server()
    {
        if (_sockfd > 0)
            close(_sockfd);
    }

private:
    int _sockfd;      // 网路文件描述符
    uint16_t _port;   // 任意地址bind 0
    std::string _ip;  // 表明服务器进程的端口号
    bool _isrunning;
    //用ip检索
    unordered_map<string, struct sockaddr_in> _online;  //注册主机
};

客户端

#include <iostream>
#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <unistd.h>
#include <strings.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <pthread.h>
#include <fcntl.h>

using namespace std;

string path = "/dev/pts/5";
struct thread_data
{
    int _sockfd;
    struct sockaddr_in _server;
    string _ip;
};

void *send_message(void * temp)
{
    thread_data *td = (struct thread_data*)temp;
    string message;
    cout << "welcome " << td->_ip << endl;
    while (true)
    {
        cout << "please enter: ";
        getline(cin, message);
        sendto(td->_sockfd, message.c_str(), message.size(), 0, (const sockaddr *)&td->_server, sizeof(td->_server));
    }
    
}

void* recv_message(void* temp)
{
    // int fd = open(path.c_str(), O_WRONLY);
    // if (fd < 0)
    // {
    //     perror("open");
    // }

    // dup2(fd, 2);

    thread_data *td = (struct thread_data *)temp;
    char buff[1024];
    sockaddr_in rec;
    socklen_t len = sizeof(rec);
    while (true)
    {
        ssize_t s = recvfrom(td->_sockfd, buff, sizeof(buff) - 1, 0, (sockaddr *)&rec, &len);
        if (s > 0)
        {
            buff[s] = 0;
            cerr << buff << endl;
        }
    }

    //close(fd);
}

int main()
{
    thread_data td;
    uint16_t port = 8000;
    //string ip = "106.54.46.147";
    string ip = "106.54.46.147";
    sockaddr_in in;
    bzero(&in, sizeof(in));
    td._server.sin_family = AF_INET;
    td._server.sin_addr.s_addr = inet_addr(ip.c_str());
    td._ip = ip;
    td._server.sin_port = htons(port);
    td._sockfd = socket(AF_INET, SOCK_DGRAM, 0);
    if (td._sockfd < 0)
    {
        cout << "socket error" << endl;
    }

    //client 需要绑定，但不显示绑定，由os自由选择
    pthread_t tid_send;
    pthread_t tid_recv;
    pthread_create(&tid_send, nullptr, send_message, &td);
    pthread_create(&tid_recv, nullptr, recv_message, &td);  
    
    pthread_join(tid_send, nullptr);
    pthread_join(tid_recv, nullptr);

    close(td._sockfd);
}

地址转换函数

介绍基于ipv4的socket网络编程，struct in_addr sin_addr表示32位的ip地址，但是我们通常用点分十进制字符串表示ip地址，一下函数可以在字符串表示和in_addr表示之间转换

其中inet_pton和inet_ntop不仅可以转换ipv4的in_addr，还可以转换ipv6的in6_addr，因此接口是void* addrptr

关于inet_ntoa

这个函数返回一个char*，自己内部申请了一块内存保存ip的结果，那么需不需要手动释放呢？

在这里插入图片描述
man手册说返回结果放在了静态存储区，不需要手动释放

当多次调用时，两个不同ip都会转换为相同的结果，以最后一个为准
因为inet_ntoa把结果放到内部的静态缓存区，第二次调用的时候会覆盖上一次结果。APUE中，明确提出inet_ntoa不是线程安全的函数，但是centos7上测试，没有出现问题，可能是内部实现加了互斥锁，在多线程环境下，推荐使用inet_ntop，这个函数由用户提供缓冲区结果，可以规避线程安全的问题

本文来自互联网用户投稿，该文观点仅代表作者本人，不代表本站立场。本站仅提供信息存储空间服务，不拥有所有权，不承担相关法律责任。如若转载，请注明出处：/a/613212.html

如若内容造成侵权/违法违规/事实不符，请联系我们进行投诉反馈qq邮箱809451989@qq.com，一经查实，立即删除！

相关文章

Required:(String) → String Found:String

Required:(String) → String Found:String

报错 Function invocation summaryFu(...) expected No value passed for parameter msg Type mismatch. Required: (String) → String Found: String class FunTest {/*参数包含函数的调用者* */fun funAndFunPropTest() { // 调用下面的test()//创建一个函数&#xff0…
阅读更多...
Colab/PyTorch - 002 Pre Trained Models for Image Classification

Colab/PyTorch - 002 Pre Trained Models for Image Classification

Colab/PyTorch - 002 Pre Trained Models for Image Classification 1. 源由2. 图像分类的预训练模型3. 示例 - AlexNet/ResNet1013.1 模型推断过程3.2 使用TorchVision加载预训练网络3.3 使用AlexNet进行图像分类3.3.1 Step1&#xff1a;加载预训练模型3.3.2 Step2&#xff1a…
阅读更多...
Redis 基础之常用数据类型及命令

Redis 基础之常用数据类型及命令

常用数据类型及命令 String&#xff08;字符串&#xff09;Hash&#xff08;哈希&#xff09;List&#xff08;列表&#xff09;Set&#xff08;集合&#xff09;zset ( sorted set&#xff1a;有序集合 )Redis setbit 命令HyperLogLogs ( 基数统计 ) Redis 比 Memcached 更优秀…
阅读更多...
HTTP 1.1 与 HTTP 1.0

HTTP 1.1 与 HTTP 1.0

什么是HTTP HTTP 就是一个 超文本传输协议 协议 : 双方 约定 发送的 域名 数据长度 连接(长连接还是短连接) 格式(UTF-8那些) 传输 :数据虽然是在 A 和 B 之间传输&#xff0c;但允许中间有中转或接力。 超文本:图片、视频、压缩包,在HTTP里都是文本 HTTP 常见状态码 比如 20…
阅读更多...
Python中的数据可视化：阶梯图matplotlib.pyplot.step()

Python中的数据可视化：阶梯图matplotlib.pyplot.step()

【小白从小学Python、C、Java】 【计算机等考500强证书考研】 【Python-数据分析】 Python中的数据可视化&#xff1a; 阶梯图 matplotlib.pyplot.step() [太阳]选择题 matplotlib.pyplot.step()的功能是&#xff1f; import matplotlib.pyplot as plt import numpy as…
阅读更多...
linux - 搭建部署ftp服务器

linux - 搭建部署ftp服务器

ftp 服务： 实现ftp功能的一个服务，安装vsftpd软件搭建一台ftp服务器 ftp协议： 文件传输协议 （file transfer protocol），在不同的机器之间实现文件传输功能， 例如 视频文件下载，源代码文件下载 公司内部：弄一个专门的文件服务器，将公司里的文档资料和视频都存放…
阅读更多...
企业网络需求及适合的解决方案

企业网络需求及适合的解决方案

近年来&#xff0c;企业网络通信需求可谓五花八门&#xff0c;变幻莫测。它不仅为企业的生产、办公、研发、销售提供全面赋能&#xff0c;同时也让企业业务规模变大成为了可能。 在当前的技术格局下&#xff0c;中大型企业常见的技术方案有很多&#xff0c;而同时也有各自不可替…
阅读更多...
武汉星起航：掌握亚马逊关键节日，抢占销售制高点

武汉星起航：掌握亚马逊关键节日，抢占销售制高点

在电子商务的浪潮中&#xff0c;亚马逊平台以其卓越的服务和庞大的用户基础&#xff0c;成为全球卖家争相入驻的热门选择。对于卖家而言&#xff0c;了解并掌握亚马逊的各大促销节日&#xff0c;无疑是提升销售业绩、扩大品牌影响力的重要一环。武汉星起航在这里将详细解析亚马…
阅读更多...
Leetcode—295. 数据流的中位数【困难】

Leetcode—295. 数据流的中位数【困难】

2024每日刷题&#xff08;132&#xff09; Leetcode—295. 数据流的中位数 实现代码 class MedianFinder { public:MedianFinder() {}void addNum(int num) {if(maxHeap.empty() || num < maxHeap.top()) {maxHeap.push(num);} else {minHeap.push(num);}if(maxHeap.size(…
阅读更多...
【Redis】用户登录校验

【Redis】用户登录校验

对于用 redis 对用户进行登录校验&#xff0c;大致可分为以下六步&#xff1a; 首先通过查询数据库来查找具有提供的用户名、密码和delFlag值为0的用户。如果未找到用户&#xff0c;则抛出一个带有消息"用户不存在"的ClientException&#xff08;用户不存在&#xf…
阅读更多...
高效工作之软件系统——数据结构登记表

高效工作之软件系统——数据结构登记表

数据结构模板 开发完软件系统后&#xff0c;往往需要进行一些登记——《软件系统数据结构登记表》 然后软件项目有60个表左右&#xff0c;难道需要手动录入&#xff0c;那肯定不可能 工欲善其事必先利其器&#xff01;go。。。同事给的模板是下图 效果图 于是想到 之前使用…
阅读更多...
RustDesk 自建服务器部署和使用教程

RustDesk 自建服务器部署和使用教程

RustDesk 是一个强大的开源远程桌面软件&#xff0c;是中国开发者的作品&#xff0c;它使用 Rust 编程语言构建&#xff0c;提供安全、高效、跨平台的远程访问体验。可以说是目前全球最火的开源远程桌面软件了&#xff0c;GitHub 星星数量达到了惊人的 64k&#xff01; 与 Team…
阅读更多...
2024数维杯B题详细思路代码数学建模高质量保姆级

2024数维杯B题详细思路代码数学建模高质量保姆级

2024年第九届数维杯大学生数学建模挑战赛题目 B 题 生物质和煤共热解问题的研究 &#xff08;1&#xff09;基于附件一&#xff0c;请分析正己烷不溶物(INS)对热解产率&#xff08;主要 考虑焦油产率、水产率、焦渣产率&#xff09;是否产生显著影响&#xff1f;并利用图像 加…
阅读更多...
pygame学习--精灵组、碰撞检测、精灵更新

pygame学习--精灵组、碰撞检测、精灵更新

pygame学习--精灵组、碰撞检测、精灵更新 一.效果二.代码 通过pygame库,模拟种群的分化 1.X从左往右移动,表示年龄的增加;Y坐标表示阶层 2.随着X坐标不断增大,圆逐渐增大,颜色也加深 3.精灵越多,碰撞后死亡的概率越大,诞生新精灵的概率越小 4.每个精灵都有随机的运动速度及Y坐标…
阅读更多...
OmniPlan Pro 4 for Mac中文激活版：项目管理的新选择

OmniPlan Pro 4 for Mac中文激活版：项目管理的新选择

OmniPlan Pro 4 for Mac作为一款专为Mac用户设计的项目管理软件&#xff0c;为用户提供了全新的项目管理体验。其直观易用的界面和强大的功能特性&#xff0c;使用户能够轻松上手并快速掌握项目管理要点。 首先&#xff0c;OmniPlan Pro 4 for Mac支持自定义视图&#xff0c;用…
阅读更多...
673. 最长递增子序列的个数（Leetcode）

673. 最长递增子序列的个数（Leetcode）

文章目录 前言一、题目描述二、解题步骤1.小demo介绍2.动态规划1.状态表示2.状态转移方程3.初始化4.填表顺序5.返回值 三、代码编写总结 前言 在本篇文章中&#xff0c;我们将会讲到leetcode中673. 最长递增子序列的个数&#xff0c;我们将会用动态规划方式解决这道问题&#…
阅读更多...
【JVM基础篇】JVM入门介绍

【JVM基础篇】JVM入门介绍

JVM入门介绍 为什么学习JVM 岗位要求 解决工作中遇到的问题 性能调优 真实案例 导出超大文件&#xff0c;系统崩溃从数据库中查询超大量数据出错消费者消费来不及导致系统崩溃Mq消息队列接受消息导致的内存泄漏业务高峰期系统失去响应 初识JVM 什么是JVM&#xff1f; JV…
阅读更多...
Vue路由开启步骤

Vue路由开启步骤

1.在控制台输入命令 //控制台下载安装npm add vue-router3.6.5 2.在main.js下导入并注册组件 import Vue from vue import App from ./App.vue//控制台下载安装npm add vue-router3.6.5 //导入 import VueRouter from "vue-router";//注册 Vue.use(VueRouter) con…
阅读更多...
鸿蒙HarmonyOS开发：List列表组件的使用详解及案例演示（二）

鸿蒙HarmonyOS开发：List列表组件的使用详解及案例演示（二）

文章目录 一、List组件简介1、List组件2、ListItem组件3、ListItemGroup组件 二、使用ForEach渲染列表三、设置列表分割线四、设置List排列方向五、索引值计算规则六、示例演示1、AlphabetIndexer组件2、代码3、效果 一、List组件简介 在我们常用的手机应用中&#xff0c;经常…
阅读更多...
uni-app（三）：离线打包与插件引用（Android）

uni-app（三）：离线打包与插件引用（Android）

离线打包与插件引用 1.下载Android离线SDK2.使用Android Studio打开离线打包项目并更新Gradle3.解决报错4.构建5.配置AppKeya.查看证书b.申请AppKeyc.配置AppKey 6.生成本地打包App资源7.拷贝App资源到Android项目中8.修改 appid9.修改Android项目配置文件10.下载证书并配置11.…
阅读更多...
最新文章

Copyright @ 2022~2023