Socket编程---UDP篇

目录

一.   UDP协议

二.   Socket编程

2.1   sockaddr家族 

2.2   接口介绍 

三.   服务端实现

四.   服务端调用实现

五.   客户端实现

六.   效果展示

一.   UDP协议

何为UDP协议的含义，上篇粗略提及了一下TCP与UDP的区别：

TCP：

• 传输层协议

• 有连接

• 可靠传输

• 面向字节流

UDP：

• 传输层协议

• 无连接

• 不可靠传输

• 面向数据报

那何为可靠，何为不可靠呢？

 TCP协议是有连接的。如果两台主机想要建立通信，就必须先建立连接，通过三次握手（后续博客会讲到）建立连接，只有当连接成功后，才能进行通信。

TCP可靠性体现在：如果数据在传输过程中出现了丢包等等情况，会有相应的解决方法。

TCP可靠性实现方法：

  1. 确认和重传： TCP 使用确认和重传机制来确保数据的完整性和可靠性。接收方会发送确认（ACK）给发送方，告知已成功接收到数据，如果发送方未收到确认，会重新发送数据。
  2. 序号和顺序控制： TCP 会为每个数据段分配一个序号，并且在接收端按序重组数据，以确保数据包按正确的顺序交付。
  3. 流量控制： TCP 使用滑动窗口协议进行流量控制，确保发送方和接收方之间的数据传输速率合理，避免了数据包的过载和丢失。
  4. 拥塞控制： TCP 还实现了拥塞控制机制，通过动态调整发送速率来避免网络拥塞，以提高整体网络性能和稳定性。

UDP协议是无连接的，也就是会说，UDP通信时，无需等待建立连接，只需拿到对应通信主机的端口号+IP地址，就能唯一确定一个进程，实现通信。

 UDP不可靠机制：

UDP 不提供数据传输的确认、重传、排序等机制。如果发送端发送了数据包，不会收到接收端的确认。因此，如果一个数据包在传输中丢失或损坏，UDP 不会重传数据，接收方也无法得知数据包的丢失。

 但是，并不是说，TCP就是百利而无一害的。前面说了，TCP还有一个特性---面向字节流，这就导致了，目标主机读取到的内容可能并不是完整的源主机发送的内容。后续讲TCP实现的时候会体现出来。

二.   Socket编程

2.1   sockaddr家族 

此处我们再次引用一张图：

  • sockaddr_in结构体是用于跨网络通信的
  • sockaddr_un结构体是用于本地通信的

 为了让套接字的网络通信和本地通信能够使用同一套函数接口,于是就出现了sockaddr结构体,该结构体与sockaddr_in和sockaddr_un的结构都不相同,但这三个结构体头部的16个比特位都是一样的,这个字段叫做协议簇。

这样好处就是：

  • socket编程涉及到的接口函数传参时，只需统一传sockaddr类型的参数即可。
  • 此时通过sockaddr结构体，将套接字网络通信和本地通信在参数方面统一

注意事项：

在进行网络通信编程时，统一定义的还是sockaddr_in结构体，只不过在调用接口时需要将sockaddr_in结构强转位sockaddr类型。

2.2   接口介绍 

  • socket创建套接字
int socket(int domain, int type, int protocol);

参数说明：

1.domin：创建套接字的域或者叫做协议家族,也就是创建套接字的类型(指定通信所用到的协议家族)

相当于sockaddr结构的前16个位的内容。

如果是本地通信就选择AF_UNIX，如果是网络通信就选择AF_INET（IPV4）或者AF_INET6（IPV6），此处我们UDP通信由于是通过网络通信，所以选择AF_INET即可。后面TCP通信也是选择AF_INET。

2.type：创建套接字时所需的服务类型(指定具体的通信协议)

  • 如果是UDP通信，选择SOCK_DGRAM（用户数据报服务），UDP是面向数据报的。
  • 如果是TCP通信，选择SOCK_STREAM（流式套接字），TCP是面向字节流的。

3.protocol：创建套接字的协议类别

此处可以指明是UDP通信还是TCP通信，但是一般设置为0，表示默认。系统会自动根据前两个参数推导出是UDP通信还是TCP通信。

 返回值：

成功的话会返回打开的文件描述符。

注意事项：

  • socket函数属于系统调用接口。
  • socket函数是被进程调用的。
  • bind绑定
int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);

 参数说明：

1.sockfd：绑定的文件的文件描述符

我们调用socket函数后，会返回一个文件描述符，这里就需要绑定这个文件描述符。通信就依赖于这个文件描述符。sockfd是全双工的，既可以收数据，又可以发数据。

2.addr：一个包含自身网络信息的结构体

我们需要确定绑定的IP和端口号，才能通信。

3.addrlen：传入的addr结构体的长度

用sizeof求得即可。

返回值说明：

成功绑定0会被返回，失败-1会被返回，错误码会被设置。

  • 本机端口序列与网络端口序列互相转换函数
//htonl：表示将长整型的本机端口序列转换为长整型的网络端口序列。
uint32_t htonl(uint32_t hostlong);//htons：表示将短整型的本机端口序列转换为短整型的网络端口序列。
uint16_t htons(uint16_t hostshort);//ntohl：表示将长整型的网络端口序列转换为长整型的本机端口序列。
uint32_t ntohl(uint32_t netlong);//ntohs：表示将短整型的网络端口序列转换为短整型的本机端口序列。
uint16_t ntohs(uint16_t netshort);

参数说明：

hostlong代表本机端口序列                                                        netlong代表网络端口序列

uint32_t即长整型                                                                       uint16_t即短整型

  • recvfrom读取数据
ssize_t recvfrom(int sockfd, void *buf, size_t len, int flags,struct sockaddr *src_addr, socklen_t *addrlen);

参数说明：

1.sockfd：对应操作的文件描述符

表示从该文件描述符索引的文件当中读取数据。

2.buf： 读取数据的存放位置


3.len： 期望读取数据的字节数


4.flags：读取的方式

一般设置为0,表示阻塞读取。


5.src_addr：对端网络相关的属性信息

包括协议簇、IP地址、端口号等。


6.addrlen：期望读取的src_addr结构体的长度

代表实际读取到的src_addr结构体的长度,这是一个输入输出型参数。

返回值说明：

成功实际读到的字节数会被返回，失败-1会被返回，错误码会被设置。

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

参数说明：

1.sockfd：对应操作的文件描述符

表示将数据写入到文件描述符索引的文件当中。

2.buf： 待写入数据的存放位置


3.len： 期望写入数据的字节数


4.flags：写入的方式

一般设置为0,表示阻塞写入。


5.dest_addr：对端网络相关的属性信息

包括协议簇、IP地址、端口号等。


6.addrlen：期望读取的dest_addr结构体的长度

代表实际读取到的dest_addr结构体的长度,这是一个输入输出型参数。

返回值说明：

成功实际写入的字节数会被返回，失败-1会被返回，错误码会被设置。 

三.   服务端实现

我们将服务端封装成一个类，并封装对应步骤在类函数中。

class UdpServer
{
public:UdpServer(uint16_t port): _sockfd(defaultfd), _port(port),_isrunning(false){}~UdpServer(){}private:int _sockfd;uint16_t _port; // 服务器所用的端口号bool _isrunning;
};

此处为什么服务端不需要IP地址呢?

这是因为服务器不好绑定一个具体的IP地址，不利于服务的广度。我们此处不设置具体的IP地址，就是为了任何IP都能连接服务器。

 服务端初始成员函数：

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.1 填充sockaddr_in结构struct sockaddr_in local;     // struct sockaddr_in 系统提供的数据类型，local是变量，用户栈上开辟空间bzero(&local, sizeof(local)); // 清空local.sin_family = AF_INET;local.sin_port = htons(_port); // 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());local.sin_addr.s_addr=INADDR_ANY;//htonl(INADDR_ANY)// 2.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");}

大概步骤就是通过socket函数创建出套接字，然后填充一个sockaddr_in结构体，最后用这个结构体绑定创建的套接字。

此处LOG函数是仿照日常生活中网络服务的思路，一些操作都有着对应的日志记录，所以创建一个日志文件，实现日志功能。

#pragma once//日志
#include<iostream>
#include<fstream>
#include<cstdio>
#include<string>
#include<ctime>
#include<unistd.h>
#include<sys/types.h>
#include<stdarg.h>
#include<pthread.h>
#include"LockGuard.hpp"using namespace std;bool gIsSave=false;
const string logname="log.txt";void SaveFile(const string& filename,const string& message)
{ofstream out(filename,ios::app);if(!out.is_open()){return;}out<<message;out.close();
}//1.日志是有等级的
enum Level
{DEBUG=0,INFO,WARNING,ERROR,FATAL
};string LevelToString(int level)
{switch(level){case DEBUG: return "Debug";break;case INFO: return "Info";break;case WARNING: return "Warning";break;case ERROR: return "Error";break;case FATAL: return "Fatal";break;default: return "Unknown";break;}
}string GetTimeString()
{time_t curr_time=time(nullptr);struct tm* format_time=localtime(&curr_time);if(format_time==nullptr) return "None";char time_buffer[64];snprintf(time_buffer,sizeof(time_buffer),"%d-%d-%d %d:%d:%d",format_time->tm_year+1900,format_time->tm_mon+1,format_time->tm_mday,format_time->tm_hour,format_time->tm_min,format_time->tm_sec);return time_buffer;
}pthread_mutex_t lock=PTHREAD_MUTEX_INITIALIZER;//2.日志是由格式的
// 日志等级 时间 代码所在的文件名/行数 日志的内容...
void LogMessage(string filename,int line,bool issave,int level,const char* format,...)
{string levelstr=LevelToString(level);string timestr=GetTimeString();pid_t selfid=getpid();//可变参数部分处理char buffer[1024];va_list arg;va_start(arg,format);vsnprintf(buffer,sizeof(buffer),format,arg);va_end(arg);LockGuard lockguard(&lock);string message;message="["+timestr+"]"+"["+levelstr+"]"+"[pid: "+to_string(selfid)+"]"+"["+filename+"]"+"["+to_string(line)+"]"+buffer+"\n";if(!issave){cout<<message;}else{SaveFile(logname,message);}
}void Test(int num,...)
{va_list arg;va_start(arg,num);while(true){int data=va_arg(arg,int);cout<<"data: "<<data<<endl;num--;}va_end(arg);//arg==NULL
}//C99新特性 __VA_ARGS__
#define LOG(level,format,...) do {LogMessage(__FILE__,__LINE__,gIsSave,level,format,##__VA_ARGS__);} while(0)
#define EnableFile() do {gIsSave=true;} while(0)
#define EnableScreen() do {gIsSave=false;} while(0)

此处我们引进了锁来保护临界资源，也是仿照C++中RAII的思路，创建了一个出了作用域自动销毁的锁。内容如下：

#ifndef __lock_GUARD_HPP__
#define __lock_GUARD_HPP__#include<iostream>
#include<pthread.h>class LockGuard
{
public:LockGuard(pthread_mutex_t* mutex):_mutex(mutex){pthread_mutex_lock(_mutex);//构造加锁}~LockGuard(){pthread_mutex_unlock(_mutex);}
private:pthread_mutex_t* _mutex;
};#endif

服务端启动成员函数：

我们可以发现现实生活中，一些软件好像啥时候都能用。比如今天晚上我失眠了。诶！打开抖音刷刷。好像不管我们几点失眠，抖音都能刷视频。所以我们见微知著，服务器应该是一直运行的，这样不论客户端什么时候去访问都能得到回应。

void Start()
{//一直运行，直到管理者不想运行了，服务器都是死循环_isrunning=true;while(true){char buffer[1024];struct sockaddr_in peer;socklen_t len=sizeof(peer);//1.我们要让server先收数据ssize_t n=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&peer,&len);if(n>0){buffer[n]=0;InetAddr addr(peer);LOG(DEBUG,"get message from [%s:%d]: %s\n",addr.Ip().c_str(),addr.Port(),buffer);//2.我们要将server收到的数据，发回给对方sendto(_sockfd,buffer,strlen(buffer),0,(struct sockaddr*)&peer,len);}}_isrunning=false;
}

大概思路就是，我们需要先通过recvfrom函数接收客户端发来的消息，然后再通过sendto函数发回给客户端。

我们发现这个函数里面出现了一个新的东西，即InetAddr，这其实是一个结构体，我们来看看吧！

#include<iostream>
#include<string>
#include<sys/types.h>
#include<sys/socket.h>
#include<arpa/inet.h>
#include<netinet/in.h>using namespace std;class InetAddr
{
private:void GetAddress(string* ip,uint16_t* port){*port=ntohs(_addr.sin_port);//网络字节序转为主机字节序*ip=inet_ntoa(_addr.sin_addr);//将网络字节序IP转为点分式十进制IP}
public:InetAddr(const struct sockaddr_in &addr):_addr(addr){GetAddress(&_ip,&_port);}string Ip(){return _ip;}uint16_t Port(){return _port;}~InetAddr(){}
private:struct sockaddr_in _addr;string _ip;uint16_t _port;
};

这个结构体重包含了sockaddr_in结构对象，以及IP地址和端口号。

那么服务端代码合起来就是：

#pragma once
#include <iostream>
#include <string>
#include <cerrno>
#include <cstring>
#include <sys/types.h>
#include <sys/socket.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <strings.h>
#include <stdlib.h>
#include "Log.hpp"
#include"InetAddr.hpp"using namespace std;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.1 填充sockaddr_in结构struct sockaddr_in local;     // struct sockaddr_in 系统提供的数据类型，local是变量，用户栈上开辟空间bzero(&local, sizeof(local)); // 清空local.sin_family = AF_INET;local.sin_port = htons(_port); // 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());local.sin_addr.s_addr=INADDR_ANY;//htonl(INADDR_ANY)// 2.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");}void Start(){//一直运行，直到管理者不想运行了，服务器都是死循环_isrunning=true;while(true){char buffer[1024];struct sockaddr_in peer;socklen_t len=sizeof(peer);//1.我们要让server先收数据ssize_t n=recvfrom(_sockfd,buffer,sizeof(buffer)-1,0,(struct sockaddr*)&peer,&len);if(n>0){buffer[n]=0;InetAddr addr(peer);LOG(DEBUG,"get message from [%s:%d]: %s\n",addr.Ip().c_str(),addr.Port(),buffer);//2.我们要将server收到的数据，发回给对方sendto(_sockfd,buffer,strlen(buffer),0,(struct sockaddr*)&peer,len);}}_isrunning=false;}~UdpServer(){}private:int _sockfd;uint16_t _port; // 服务器所用的端口号bool _isrunning;
};

四.   服务端调用实现

由于我们将服务端封装成了一个类，所以需要创建出对象，然后调用初识函数以及开始函数。

#include<iostream>
#include<memory>
#include"UdpServer.hpp"
#include"Log.hpp"
using namespace std;void Usage(string proc)
{cout<<"Usage:\n\t"<<proc<<" local_port\n"<<endl;
}// ./udpserver port
int main(int argc,char *argv[])
{if(argc!=2){Usage(argv[0]);exit(USAGE_ERROR);}EnableScreen();//string ip=argv[1];uint16_t port=stoi(argv[1]);unique_ptr<UdpServer> usvr=make_unique<UdpServer>(port);usvr->InitServer();usvr->Start();return 0;
}

思路就是，创建一个对象，依次调用两个成员函数，即可创建出服务端。

五.   客户端实现

客户端的创建前面一部分还是跟服务端一样，即创建套接字，构建目标主机结构体信息，即构建sockaddr_in结构体信息。唯一不同的是，客户端是不需要显示bind的。

为什么呢？

为了防止客户端的端口冲突。如果我们直接将客户端绑定了一个确定的端口号，其他人是不知道的，每个人都绑定一个确定的端口号，势必会有冲突。

那什么时候绑定呢？

在客户端首次发送消息数据的时候，操作系统会给客户端随机分配端口号，以防端口冲突。

void Usage(string proc)
{cout<<"Usage:\n\t"<<proc<<" serverip serverport\n"<<endl;
}// ./udpclient serverip serverport
int main(int argc,char *argv[])
{if(argc!=3){Usage(argv[0]);exit(1);}string serverip=argv[1];uint16_t serverport=stoi(argv[2]);//1.创建socketint sockfd=socket(AF_INET,SOCK_DGRAM,0);if(sockfd<0){cerr<<"socket error"<<endl;}//2.client一定要bind，client也有自己的ip和port，但是不建议显示(和server一样用bind函数)bind//a.那如何bind呢？当udp client首次发送数据的时候，os会自动随机的给client进行bind--为什么？要bind，必然要和port关联！防止client port冲突//b.什么时候bind？首次发送数据的时候//构建目标主机的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());
}

下面就可以直接与服务端通信了。

string message;
//3.直接通信即可
while(true)
{cout<<"Please Enter# ";getline(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;cout<<"server echo# "<<buffer<<endl;}
}

通信时，首先通过sendto将要发送的信息发送到服务端，服务端收到后会将信息发送回来，然后再用recvfrom函数收到信息即可。

客户端整体代码如下：

#include<iostream>
#include<string>
#include<cstdio>
#include<cstring>
#include<unistd.h>
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>using namespace std;void Usage(string proc)
{cout<<"Usage:\n\t"<<proc<<" serverip serverport\n"<<endl;
}// ./udpclient serverip serverport
int main(int argc,char *argv[])
{if(argc!=3){Usage(argv[0]);exit(1);}string serverip=argv[1];uint16_t serverport=stoi(argv[2]);//1.创建socketint sockfd=socket(AF_INET,SOCK_DGRAM,0);if(sockfd<0){cerr<<"socket error"<<endl;}//2.client一定要bind，client也有自己的ip和port，但是不建议显示(和server一样用bind函数)bind//a.那如何bind呢？当udp client首次发送数据的时候，os会自动随机的给client进行bind--为什么？要bind，必然要和port关联！防止client port冲突//b.什么时候bind？首次发送数据的时候//构建目标主机的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());string message;//3.直接通信即可while(true){cout<<"Please Enter# ";getline(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;cout<<"server echo# "<<buffer<<endl;}}return 0;
}

六.   效果展示

最后服务端和客户端通信的效果如下：

可以看到服务端在创建套接字成功，bind成功之后开始工作。

客户端发送消息，服务端收到消息，并返还给客户端。 

总结：

好了，到这里今天的知识就讲完了，大家有错误一点要在评论指出，我怕我一人搁这瞎bb，没人告诉我错误就寄了。

祝大家越来越好，不用关注我（疯狂暗示）

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

如若内容造成侵权/违法违规/事实不符，请联系多彩编程网进行投诉反馈email:809451989@qq.com，一经查实，立即删除！

相关文章

SpringBoot集成kafka-消息转发@sendTo()注解

SpringBoot集成kafka-消息转发@sendTo()注解

SpringBoot集成kafka-消息转发sendTo 1、消费者2、生产者3、实体类对象4、JSON工具类5、配置文件application.yml6、测试类7、测试 1、消费者 启动消费者进行消息监听&#xff0c;消费者A监听到生产者发送的消息使用sendTo()注解将消息转发给消费者B package com.power.consu…
阅读更多...
Django+Vue二手交易平台的设计与实现

Django+Vue二手交易平台的设计与实现

目录 1 项目介绍2 项目截图3 核心代码3.1 需要的环境3.2 Django接口层3.3 实体类3.4 config.ini3.5 启动类3.5 Vue 4 数据库表设计5 文档参考6 计算机毕设选题推荐7 源码获取 1 项目介绍 博主个人介绍&#xff1a;CSDN认证博客专家&#xff0c;CSDN平台Java领域优质创作者&…
阅读更多...
cesium 地形获取和生成

cesium 地形获取和生成

1.先从网上下载12.5m精度的地形，然后叠加无人机的地形数据 2.使用global mapper pro合并并导出完整的tiff 3.使用cesiumLab进行tiff的文件数据切片生成terrain格式的数据
阅读更多...
.NET HandyControl 深度解析：一个现代化的UI控件库

.NET HandyControl 深度解析：一个现代化的UI控件库

文章目录 前言一、选择HandyControl的原因二、如何使用HandyControl1.安装HandyControl2.使用代码例子 总结 前言 在.NET开发领域&#xff0c;UI&#xff08;用户界面&#xff09;设计的美观性和易用性对于应用程序的成功至关重要。为了帮助开发者快速构建现代化、美观且用户友…
阅读更多...
如何使用住宅代理获取价格对比和更多选择

如何使用住宅代理获取价格对比和更多选择

在购物和预订过程中&#xff0c;网站通常会根据用户的地理位置提供不同的价格和库存信息。这种做法称为地理定价或区域定价。使用静态住宅代理可以帮助用户准确查看他们想要了解的区域&#xff0c;获得更多选择和更优惠的价格。 查找更低的价格&#xff1a; 价格差异&#xff1…
阅读更多...
CSS\JS实现页面背景气泡logo上浮效果

CSS\JS实现页面背景气泡logo上浮效果

效果图&#xff1a; 单容器显示气泡&#xff1a; <!DOCTYPE html> <html lang"en"> <head><meta charset"UTF-8"><meta name"viewport" content"widthdevice-width, initial-scale1.0"><title>Bu…
阅读更多...
c++习题27-大整数减法

c++习题27-大整数减法

目录 一&#xff0c;题目 二&#xff0c;思路 三&#xff0c;代码 一&#xff0c;题目 输入 共2行&#xff0c;第1行是被减数a&#xff0c;第2行是减数b(a > b)。每个大整数不超过200位&#xff0c;不会有多余的前导零。 输出 一行&#xff0c;即所求的差。 样例输入1…
阅读更多...
精密机械零件加工企业为制造业提供关键支撑

精密机械零件加工企业为制造业提供关键支撑

在当今高度发达的制造业中&#xff0c;精密机械零件加工企业扮演着至关重要的角色&#xff0c;以其精湛的工艺和严谨的态度&#xff0c;为制造业的各个领域提供着关键的支撑。 一、高精度制造&#xff0c;奠定产品质量基础 精密机械零件加工企业以其精湛的加工技术&#xff0c;…
阅读更多...
android studio 设置gradle jdk

android studio 设置gradle jdk

1. 左上角点击file 2. 按照如下点击&#xff1a; 3. 即可修改gradle jdk
阅读更多...
灵办AI搜索引擎和文档总结工具

灵办AI搜索引擎和文档总结工具

前言—— 在信息爆炸的时代&#xff0c;如何高效地获取和处理知识成为了每个人面临的挑战。随着人工智能技术的迅猛发展&#xff0c;本文将深入探讨这一创新工具的功能与优势&#xff0c;以及如何在日常生活和工作中充分利用它&#xff0c;开启智能化的信息获取新篇章。 点击…
阅读更多...
nexus 清理 docker 镜像

nexus 清理 docker 镜像

下载配置 nexus-cli 看网上文档都用如下地址&#xff0c;但现在已经不能下载&#xff1a; wget https://s3.eu-west-2.amazonaws.com/nexus-cli/1.0.0-beta/linux/nexus-cli chmod x nexus-cli 在 github 上下载&#xff1a; wget https://github.com/heyonggs/nexus-cli/r…
阅读更多...
【DSP+FPGA】基于DSP+FPGA XC7K325T与TMS320C6678的通用信号处理平台

【DSP+FPGA】基于DSP+FPGA XC7K325T与TMS320C6678的通用信号处理平台

DSP FPGA 协同处理架构板载 1 个TMS320C6678 多核DSP处理节点板载 1 片 XC7K325T FPGA处理节点板载 1 个FMC 接口板载4路SFP光纤接口FPGA 与 DSP 之间采用高速Rapid IO互联 基于FPGA与DSP协同处理架构的通用高性能实时信号处理平台&#xff0c;该平台采用1片TI的KeyStone系列多…
阅读更多...
H5手机端调起支付宝app支付

H5手机端调起支付宝app支付

1.调起APP页面如下 步骤 1.让后端对接一下以下文档&#xff08;手机网站支付通过alipays协议唤起支付宝APP&#xff09; https://opendocs.alipay.com/open/203/107091?pathHash45006f4f&refapi 2.后端接口会返回一个form提交表单 html&#xff1a;在页面中定义一个d…
阅读更多...
Linux的远程登录教程（超详细）

Linux的远程登录教程（超详细）

我们在进行远程登录时要用的一种协议叫SSH&#xff0c;那什么叫SSH呢&#xff1f; SSH&#xff08;Secure Shell&#xff09;是一种网络协议&#xff0c;用于在不安全的网络中提供安全的远程登录和其他网络服务。它通过加密技术确保数据在传输过程中的机密性和完整性&#xff…
阅读更多...
实训第三十二天（学习playbook-roles，脚本创建数据库和表，mycat读写分离）

实训第三十二天（学习playbook-roles，脚本创建数据库和表，mycat读写分离）

1、roles&#xff08;角色&#xff09;介绍 roles(⻆⾊): 就是通过分别将variables, tasks及handlers等放置于单独 的⽬录中,并可以便捷地调⽤它们的⼀种机制。 假设我们要写⼀个playbook来安装管理lamp环境&#xff0c;那么这个 playbook就会写很⻓。所以我们希望把这个很⼤的…
阅读更多...
从被动应对到主动防御：开发团队技术故障处理能力的全面升级，未雨绸缪，制胜未来！

从被动应对到主动防御：开发团队技术故障处理能力的全面升级，未雨绸缪，制胜未来！

开发团队如何应对突发的技术故障和危机&#xff1f; 网易云音乐 时间&#xff1a;2024年8月19日下午 问题&#xff1a; 服务器故障&#xff1a;网易云音乐网页端出现“502 Bad Gateway”报错&#xff0c;App也无法正常使用。影响&#xff1a;用户无法正常登录和使用app、we…
阅读更多...
MAC +win10 笔记本， OBS 桌面音频不起作用 问题 总结

MAC +win10 笔记本， OBS 桌面音频不起作用 问题 总结

现象： MAC+WIN10笔记本，音频是好好的，可以听，但是OBS使用的时候，桌面音频条，保持静止，录制的视频，也没有系统声音。 问题排查 1、通常的OBS无法捕获音频解决方法 1）、 驱动问题，更新到最新驱动 2）、声音参数配置问题 3）、右侧小喇叭，音量合成器中， 4）、设…
阅读更多...
【Word与WPS如何冻结首行首列及窗口】

【Word与WPS如何冻结首行首列及窗口】

1.Word如何冻结首行首列及窗口 microsoft word 中锁定表头是一项实用的功能&#xff0c;可让您在滚动文档时保持表头可见。这在处理大型文档或包含大量数据的表格时非常有用。php小编柚子将为您详细介绍 word 锁定表头位置的方法&#xff0c;帮助您轻松掌握这项实用技巧。 1.…
阅读更多...
【STM32】驱动LCD

【STM32】驱动LCD

没买LCD屏&#xff0c;没有上机实践&#xff0c;只是学习了理论。 大部分图片来源&#xff1a;正点原子HAL库课程 专栏目录&#xff1a;记录自己的嵌入式学习之路-CSDN博客 目录 1 屏幕接口 2 屏幕驱动的基本步骤 3 8080时序的各信号线 4 8080的读和写 5 屏…
阅读更多...
＜Rust＞egui学习之小部件（八）：如何在窗口中添加滑动条slider部件？

＜Rust＞egui学习之小部件（八）：如何在窗口中添加滑动条slider部件？

前言 本专栏是关于Rust的GUI库egui的部件讲解及应用实例分析&#xff0c;主要讲解egui的源代码、部件属性、如何应用。 环境配置 系统&#xff1a;windows 平台&#xff1a;visual studio code 语言&#xff1a;rust 库&#xff1a;egui、eframe 概述 本文是本专栏的第八篇博…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023