Linux Socket 分包 和 粘包 问题 - 解决方案

news2024/11/25 10:34:06

分包和粘包在TCP网络编程中是非常常见的，分包会造成 接收端 接收的数据不全的问题，粘包会造成接收多余的数据的文件。

这里做一个举例，例如客户端A要发送字符串“helloworld”给服务器B，A是一次性发送，但TCP有可能会将其分成两个包去发送，如分成“hello”和“world”，当服务器不知道数据已经被分成两个包去发送了，它只是接收也一个包，即只接收了“hello”，造成数据接收不全的问题！

或者说，当发送的数据过小时，却连续发送多次时，TCP会将他们同时打包，一起发送，接收时如果也是一次性接收，那么就会接收了多余的数据了！

目录

一、TCP分包

二、TCP粘包

三、分包和粘包的解决方案

1. 组合数据关键代码

2. 解析数据关键代码

四、示例

client.c

server.c

编译运行测试

五、总结

一、TCP分包

场景：发送方发送字符串”helloworld”，接收方却分别接收到了两个数据包：字符串”hello”和”world”；

发送端发送了数量较多的数据，接收端读取数据时候数据分批到达，造成一次发送多次读取；

造成分包的原因：

TCP是以段（Segment）为单位发送数据的,建立TCP链接后,有一个最大消息长度（MSS）.如果应用层数据包超过MSS,就会把应用层数据包拆分,分成两个段来发送.

这个时候接收端的应用层就要拼接这两个TCP包，才能正确处理数据。

相关的,路由器有一个MTU（ 最大传输单元）一般是1500字节,除去IP头部20字节,留给TCP的就只有MTU-20字节。所以一般TCP的MSS为MTU-20=1460字节；

当应用层数据超过1460字节时,TCP会分多个数据包来发送。

二、TCP粘包

场景：发送方发送字符串”helloworld”，接收方却接收到了两个字符串”hello”和”world”；

发送端发送了几次数据，接收端一次性读取了所有数据，造成多次发送一次读取；通常是网络流量优化，把多个小的数据段集满达到一定的数据量，从而减少网络链路中的传输次数；

造成TCP粘包的原因：

TCP为了提高网络的利用率,会使用一个叫做Nagle的算法.该算法是指,发送端即使有要发送的数据,如果很少的话,会延迟发送.如果应用层给TCP传送数据很快的话,就会把两个应用层数据包“粘”在一起,TCP最后只发一个TCP数据包给接收端.

三、分包和粘包的解决方案

发送数据前，给数据附加固定的头部长度：

1. 包标识：  包头部的特殊标识，用来标识包的开始；

2. 数据长度：数据包的大小，固定长度，2、4 或者8字节；

3. 数据内容：数据内容，长度为数据头定义的长度大小；

假设包标识是FBEB，即，如果发送的数据是helloworld，则组合发送的数据为：FBEB10helloworld

实际操作如下：

a）发送端：先发送包表示和长度，再发送数据内容。

b）接收端：先解析本次数据包的大小N，再读取N个字节，这N个字节就是一个完整的数据内容。

具体流程如下：

按照这种思路，就可以解决分包和粘包的问题了！

1. 组合数据关键代码

#define DATA_LEN_BYTES  4
const char *TAG = "FBEB";

char *message = "helloworld";

int ms_len = strlen(message);  
int tag_len = strlen(TAG);

// 组装数据包
char *buf = (char*)malloc(ms_len + tag_len + DATA_LEN_BYTES);
memset(buf, '\0', ms_len + tag_len + DATA_LEN_BYTES);

strcpy(buf, TAG);
*((int *)(buf + tag_len)) = ms_len;
memcpy(buf + tag_len + DATA_LEN_BYTES, message, ms_len);

这样组合出来的数据就是符合上面我们规定的那样了！

解析再按相应规则进行解析就可以得到数据了！

2. 解析数据关键代码

#define DATA_LEN_BYTES  4
const char *TAG = "FBEB";

int tag_len = strlen(TAG);
char buf[1024] = { '\0' };


// 1. 首先接收头部信息
read(client_sock, buf, tag_len + DATA_LEN_BYTES);


// 2. 通过strncmp比较，即可得知数据开始部分是否是我们定义的标识
if (strncmp(buf, TAG, tag_len) == 0) { /* 符合条件 */ }


// 3. 获得实际数据的大小
int dataLen = *((int *)(buf + tag_len));


// 4. 循环接收数据，存储到buf中
int count = 0;
int readLen = 0;
while (count < dataLen) {
    readLen = read(client_sock, buf + count, dataLen - count);    // dataLen-count：还需要接收多少数据
    
    count += readLen;    // 统计已经接收了多少数据
}

这样，不管是分包和粘包问题都可以正常的接收了！

四、示例

客户端发送消息给服务器，服务器发送消息给客户端！模拟分包发送！

客户端发送数据给服务器时，将数据拆成三个包发送；服务器发送数据给客户端时，将数据包拆成两个包发送！

client.c

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <string.h>
#include <errno.h>

#define SERVER_PORT     4567
#define SERVER_IP       "127.0.0.1"
#define DATA_LEN_BYTES  4

const char *TAG = "Jtom";




int read_package(int client_sock, char *buf, unsigned int len) {
    int readLen = 0;    // 当前读取字节数
    int count = 0;      // 已经读取字节数
    
    if (buf == NULL || client_sock < 1) {
        printf("Parameters are wrong!\n");
        return -1;
    }
      
    
    int tag_len = strlen(TAG);

    int ret = read(client_sock, buf, tag_len + DATA_LEN_BYTES);
    if (-1 == ret) {
        fprintf(stderr, "read failed! reason：%s", strerror(errno));
        return ret;
    } else if (0 == ret) {
        printf("1read data return 0!\n");
        return ret;
    }

    // 对TAG进行检查
    if (strncmp(buf, TAG, tag_len) == 0) {
        int dataLen = *((int *)(buf + tag_len));
        //printf("dataLen = %d\n", dataLen);
        
        int failCount = 0;  // 失败重试
        
        // 读取数据部分
        count = 0;
        readLen = 0;
        while (count < dataLen) {
            readLen = read(client_sock, buf + count, dataLen - count);
            printf("readLen = %d\n", readLen);
            if (-1 == readLen) {
                if (5 > failCount) {
                    failCount++;
                    readLen = 0;
                } else {
                    fprintf(stderr, "read failed! reason：%s", strerror(errno));
                    return readLen;
                }
                
            } else if (0 == readLen) {
                if (5 > failCount) {
                    failCount++;
                    readLen = 0;
                } else {
                    printf("2read data return 0!\n");
                    return ret;
                } 
            }
            
            count += readLen;
        }
        
        return dataLen;
    }
}    



// 线程执行函数
void *my_thread_handle(void *arg) {
    
    char buf[1024] = { '\0' };
    int sockfd = *(int *)arg;
    int failCount = 0;  // 失败重试5次
    
    while (1) {
       // 读取服务器发送回来的信息
        int len = read_package(sockfd, buf, sizeof(buf));
        if (len > 0) {
            buf[len] = '\0';
            printf("receive[%d]: %s", len, buf);
        } else {
            if (5 > failCount) {
                failCount++;
                sleep(1);
            } else {               
                fprintf(stderr, "connect server off!\n");                             
                break;
            }
        }            
        
        if (strncmp(buf, "end", 3) == 0) {
            break;
        }
        memset(buf, '\0', sizeof(buf));
    }
    
    pthread_exit(NULL);
}



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

    int sockfd;
    char message[1024] = { '\0' };
    struct sockaddr_in servaddr;
    int n;
    char *buf = NULL;


    sockfd = socket(AF_INET, SOCK_STREAM, 0);

    memset(&servaddr, '\0', sizeof(struct sockaddr_in));

    servaddr.sin_family = AF_INET;
    inet_pton(AF_INET, SERVER_IP, &servaddr.sin_addr);
    servaddr.sin_port = htons(SERVER_PORT);

    int ret = connect(sockfd, (struct sockaddr *)&servaddr, sizeof(servaddr));
    if (-1 == ret) {
        printf("connet failed! reason：%s\n", strerror(errno));
        exit(1);
    }
    
    
    // 创建线程取接收客户端发送过来的数据
    pthread_t mythread;
    // 创建线程
    ret = pthread_create(&mythread, 0, my_thread_handle, &sockfd);
    if (0 != ret) {
        printf("create thread failed!\n");
        exit(1);
    }
    
    
    while (1) {
        fgets(message, 1024, stdin);
        
        int ms_len = strlen(message);  
        int tag_len = strlen(TAG);
        
        // 组装数据包
        buf = (char*)malloc(ms_len + tag_len + DATA_LEN_BYTES);
        memset(buf, '\0', ms_len + tag_len + DATA_LEN_BYTES);
        
        strcpy(buf, TAG);
        *((int *)(buf + tag_len)) = ms_len;
        memcpy(buf + tag_len + DATA_LEN_BYTES, message, ms_len);
        
        
        // 先发送头部，即标识符和发送数据的大小
        write(sockfd, buf, tag_len + DATA_LEN_BYTES);
        
        // 模拟发送三个包
        write(sockfd, buf + tag_len + DATA_LEN_BYTES, 1);
        sleep(1);
        write(sockfd, buf + tag_len + DATA_LEN_BYTES + 1, 1);
        sleep(1);
        write(sockfd, buf + tag_len + DATA_LEN_BYTES + 2, ms_len - 2);
        
        if (strncmp(buf + tag_len + DATA_LEN_BYTES, "exit", 4) == 0) {
            free(buf);
            break;
        }
        free(buf);
    }
   

    printf("finished.\n");
    close(sockfd);

    return 0;
}

server.c

#include <stdio.h>
#include <unistd.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string.h>        // strerror
#include <ctype.h>
#include <arpa/inet.h>
#include <netinet/in.h>
#include <stdlib.h>
#include <errno.h>
 

#define SERVER_PORT     4567
#define SERVER_IP       "127.0.0.1"
#define DATA_LEN_BYTES  4

const char *TAG = "Jtom";



int read_package(int client_sock, char *buf, unsigned int len) {
    int readLen = 0;    // 当前读取字节数
    int count = 0;      // 已经读取字节数
    
    if (buf == NULL || client_sock < 1) {
        printf("Parameters are wrong!\n");
        return -1;
    }
      
    
    int tag_len = strlen(TAG);

    int ret = read(client_sock, buf, tag_len + DATA_LEN_BYTES);
    if (-1 == ret) {
        fprintf(stderr, "read failed! reason：%s", strerror(errno));
        return ret;
    } else if (0 == ret) {
        printf("read data return 0!\n");
        return ret;
    }

    // 对TAG进行检查
    if (strncmp(buf, TAG, tag_len) == 0) {
        int dataLen = *((int *)(buf + tag_len));
        //printf("dataLen = %d\n", dataLen);
        
        int failCount = 0;  // 失败重试
        
        // 读取数据部分
        count = 0;
        readLen = 0;
        while (count < dataLen) {
            readLen = read(client_sock, buf + count, dataLen - count);
            printf("readLen = %d\n", readLen);
            if (-1 == readLen) {
                if (5 > failCount) {
                    failCount++;
                    readLen = 0;
                } else {
                    fprintf(stderr, "read failed! reason：%s", strerror(errno));
                    return readLen;
                }
                
            } else if (0 == readLen) {
                if (5 > failCount) {
                    failCount++;
                    readLen = 0;
                } else {
                    printf("read data return 0!\n");
                    return ret;
                } 
            }
            
            count += readLen;
        }
        
        return dataLen;
    }
}    



// 线程执行函数
void *my_thread_handle(void *arg) {
    
    char buf[1024] = { '\0' };
    int client_sock = *(int *)arg;
    int failCount = 0;
    
    while (1) {
       // 读取服务器发送回来的信息
        int len = read_package(client_sock, buf, sizeof(buf));
        if (len > 0) {
            buf[len] = '\0';
            printf("receive[%d]: %s", len, buf);
        } else {
            if (5 > failCount) {
                failCount++;
                sleep(1);
            } else {
                fprintf(stderr, "connect client off!\n");                             
                break;
            }
        }       
        
        if (strncmp(buf, "end", 3) == 0) {
            break;
        }
        memset(buf, '\0', sizeof(buf));
    }
    
    pthread_exit(NULL);
}
 
 
 
int main(void) {
	
	int ret = 0;
	int sock;	// 通信套接字
	struct sockaddr_in server_addr;
    char message[1024] = { '\0' };
	
	// 1.创建通信套接字
	sock = socket(AF_INET, SOCK_STREAM, 0);
	if (-1 == sock) {
		fprintf(stderr, "create socket error, reason: %s\n", strerror(errno));
		exit(-1);
	}
	
	// 2.清空标签，写上地址和端口号
	bzero(&server_addr, sizeof(server_addr));
	
	server_addr.sin_family = AF_INET;	// 选择协议组ipv4
	server_addr.sin_addr.s_addr = htonl(INADDR_ANY);	// 监听本地所有IP地址
	server_addr.sin_port = htons(SERVER_PORT);			// 绑定端口号
	
	// 3.绑定
	ret = bind(sock, (struct sockaddr *)&server_addr, sizeof(server_addr));
	if (-1 == ret) {
		fprintf(stderr, "socket bind error, reason: %s\n", strerror(errno));
		close(sock);
		exit(-2);
	}
	
	// 4.监听，同时监听128个请求
	ret = listen(sock, 128);
	if (-1 == ret) {
		fprintf(stderr, "listen error, reason: %s\n", strerror(errno));
		close(sock);
		exit(-2);
	}
	
	printf("等待客户端的链接\n");
    
    struct sockaddr_in client;
    int client_sock;
    char client_ip[64];
    
    socklen_t client_addr_len;		
    client_addr_len = sizeof(client);
    // 5.接受
    client_sock = accept(sock, (struct sockaddr *)&client, &client_addr_len);
    if (-1 == client_sock) {
        perror("accept error");
        close(sock);
        exit(-3);
    }
    
    // 打印客户端IP地址和端口号
    printf("client ip: %s\t port: %d\n",
            inet_ntop(AF_INET, &client.sin_addr.s_addr, client_ip, sizeof(client_ip)),
            ntohs(client.sin_port));
    
    
    // 创建线程取接收客户端发送过来的数据
    pthread_t mythread;
    // 创建线程
    ret = pthread_create(&mythread, 0, my_thread_handle, &client_sock);
    if (0 != ret) {
        printf("create thread failed!\n");
        exit(1);
    }
    
    
	
	while (1) {
		
		fgets(message, sizeof(message), stdin);
        int ms_len = strlen(message);  
        int tag_len = strlen(TAG);
        
        // 组装数据包
        char *buf = (char*)malloc(ms_len + tag_len + DATA_LEN_BYTES);  
        memset(buf, '\0', ms_len + tag_len + DATA_LEN_BYTES);
        
        strcpy(buf, TAG);
        *((int *)(buf + tag_len)) = ms_len;
        memcpy(buf + tag_len + DATA_LEN_BYTES, message, ms_len);
        
        
        // 先发送头部，即标识符和发送数据的大小
        write(client_sock, buf, tag_len + DATA_LEN_BYTES);
        
        // 模拟发送两个包
        write(client_sock, buf + tag_len + DATA_LEN_BYTES, 1);
        sleep(1);
        write(client_sock, buf + tag_len + DATA_LEN_BYTES + 1, ms_len - 1);
        
        if (strncmp(buf + tag_len + DATA_LEN_BYTES, "exit", 4) == 0) {
            free(buf);
            break;
        }

        free(buf);
	}
	
	// 9.关闭服务器套接字
	close(sock);
    close(client_sock);
	
	return 0;
}

编译运行测试

gcc client.c -lpthread -o client

gcc server.c -lpthread -o server

某一端输入exit退出后，另一端会持续读取6次，如果超过6次，也就结束了，但也还要输入exit退出才行！

五、总结

TCP的分包和粘包相关问题已经列出来了，解决办法也记录下来了；

下次还需要写TCP编程时，需要注意分包和粘包的问题，然后组合数据去发送！

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

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

相关文章

A Unified Conditional Framework for Diffusion-based Image Restoration

A Unified Conditional Framework for Diffusion-based Image Restoration

A Unified Conditional Framework for Diffusion-based Image Restoration (Paper reading) Yi Zhang, CUHK, CN, arXiv2023, Cited:0, Code, Paper 1. 前言 最近&#xff0c;扩散概率模型&#xff08;Diffusion Probabilistic Models&#xff0c;DPMs&#xff09;在图像生成…
阅读更多...
Android 自定义View 之 饼状进度条

Android 自定义View 之 饼状进度条

饼状进度条 前言正文一、XML样式二、构造方法三、测量四、绘制① 绘制描边① 绘制进度 五、API方法六、使用七、源码 前言 前面写了圆环进度条&#xff0c;这次我们来写一个饼状进度条&#xff0c;首先看一下效果图&#xff1a; 正文 效果图感觉怎么样呢&#xff1f;下面我们…
阅读更多...
GLTF/GLB模型轻量化简明教程

GLTF/GLB模型轻量化简明教程

GLB 文件格式很方便&#xff0c;因为它包含渲染所需的所有文件&#xff0c;包括纹理。 但是&#xff0c;根据用途&#xff0c;你可能希望简化文件&#xff0c;因为它有时非常详细。 在本文中&#xff0c;我将使用 gltf-transform 来执行简化&#xff0c;并且假设你使用的是 Wi…
阅读更多...
0x23 Read Version Information Service

0x23 Read Version Information Service

0x23 Read Version Information Service ReadMemoryByAddress服务允许客户端通过提供的起始地址和要读取的内存大小向服务器请求内存数据。 ReadMemoryByAddress请求消息用于请求由参数memoryAddress和memorySize标识的服务器的内存数据。 用于memoryAddress和memorySize参数的…
阅读更多...
SAP-MM-原始接受订单

SAP-MM-原始接受订单

业务场景&#xff1a; 供应商是强势供应商&#xff0c;产品紧缺&#xff0c;订购货物需要自提&#xff0c;运损也归我们公司&#xff0c;而且立刻付款&#xff0c;那么就不能按以往操作&#xff0c;等供应商送货&#xff0c;再开票 我们在付款&#xff0c;那么SAP如何快速实现…
阅读更多...
JS 排序算法

JS 排序算法

在前端工作中算法不常用&#xff0c;但是排序可能会经常会用&#xff0c;下面学习几种常用算法。 引用借鉴&#xff1a;js的五种排序方法_js排序_木可生森的博客-CSDN博客 JS 常见的排序算法_js排序算法_东风过境F的博客-CSDN博客 1.冒泡排序&#xff1a; 思路&#xff1a;逐次…
阅读更多...
儿童节快乐，基于CSS3绘制一个游乐场动效界面

儿童节快乐，基于CSS3绘制一个游乐场动效界面

0️⃣写在前面 让代码创造童话&#xff0c;共建快乐世界。六一儿童节——这是属于孩子们的节日&#xff0c;也是属于我们大人的节日。让我们一起「致童真」&#xff0c;用代码&#xff08;HTMLCSSJS&#xff09;创造出一个游乐场&#xff0c;让这个世界多一份快乐和惊喜&#x…
阅读更多...
如何把vue项目部署服务器（宝塔面板）上

如何把vue项目部署服务器（宝塔面板）上

一&#xff0c;vue项目打包 首先我们把准备好的vue项目进行打包&#xff1a; 输入命令&#xff1a;npm run build 生成dist文件 二、进入宝塔管理界面&#xff0c;点击网站&#xff0c;然后点击添加站点 三。按下面输入 点设置 四。 输入好点添加&#xff0c;注意&#x…
阅读更多...
【Python开发】FastAPI 04：响应模型

【Python开发】FastAPI 04：响应模型

响应模型是指在接口调用之后&#xff0c;服务器返回给客户端的数据模型。这个数据模型可以是一个简单的字符串&#xff0c;也可以是一个复杂的数据结构&#xff0c;如 JSON 或 XML 格式的数据。本篇文章将详细介绍 FastAPI 中的响应模型。 目录 1 响应模型 1.1 response_mode…
阅读更多...
HTML--Java EE

HTML--Java EE

目录 一、认识 HTML 标签 二、HTML 文件基本结构 三、开发者工具 四、HTML常见标签 1.注释标签 2.标题标签&#xff08;h1-h6&#xff09; 3.段落标签&#xff08;p&#xff09; 4.换行标签 5.格式化标签 6.图片标签&#xff08;img&#xff09; 6.1网络路径 6.2绝…
阅读更多...
Mysql索引慢解决

Mysql索引慢解决

索引慢解决 explain关键字 explainSQL id执行顺序&#xff0c;id相同从上到下&#xff1b;id不同&#xff0c;如果是子查询id序号会递增&#xff0c;id值越大优先级越高&#xff1b;id相同和不同都存在时&#xff0c;id相同理解为一组&#xff0c;从上往下顺序执行&#xff0…
阅读更多...
最优化——几种重要的凸集

最优化——几种重要的凸集

引言 这是中科大最优化理论的笔记&#xff0c;中科大凌青老师的凸优化课程&#xff0c;详尽易懂&#xff0c;基础扎实。不论是初学者还是从业多年的人&#xff0c;都值得系统地好好学一遍。 本文介绍种重要的凸集:超平面与半空间、球和椭球、多面体、单纯形。 超平面与半空间…
阅读更多...
202314读书笔记|《孩子们的诗》——简单的语言，击中每个人心中的诗意

202314读书笔记|《孩子们的诗》——简单的语言，击中每个人心中的诗意

202314读书笔记|《孩子们的诗》——简单的语言&#xff0c;击中每个人心中的诗意 《孩子们的诗》作者果麦。这本书中的诗都是孩子们写的&#xff0c;虽然他们或许并不认为自己写的是诗。每个人都想一直做一个孩子&#xff0c;好奇、天真、单纯、善良、简单&#xff0c;多美美好…
阅读更多...
【产品应用】一体化步进电机在全自动折页机的应用

【产品应用】一体化步进电机在全自动折页机的应用

随着科技的不断发展&#xff0c;机器人技术也越来越成熟&#xff0c;智能化和自动化已经成为了现代工业的发展趋势。在这个趋势下&#xff0c;全自动折页机作为一种高效、精确的印刷设备&#xff0c;被广泛应用于各种印刷品的生产中。而一体化步进电机作为全自动折页机的关键部…
阅读更多...
SpringBoot+Vue 前后端分离在线学习平台-在线教育平台

SpringBoot+Vue 前后端分离在线学习平台-在线教育平台

SpringBootVue 前后端分离在线学习平台-在线教育平台 本项目是完整的前后端分离&#xff0c;在线学习系统。【有完整部署视频教程】 创新点&#xff1a; ①基于阿里云短信平台完成手机号变更【短信验证码】 ②基于支付宝沙箱支付完成在线购买课程【在线支付】 ③基于apach-echa…
阅读更多...
【Python】函数 ② ( 函数参数定义和使用 | 形式参数和实际参数 )

【Python】函数 ② ( 函数参数定义和使用 | 形式参数和实际参数 )

文章目录 一、函数参数定义和使用二、形式参数和实际参数 一、函数参数定义和使用 Python 函数参数 作用 : 在 Python 函数 执行时 , 可以 接受 外部 函数调用者 提供的数据 ; 在 Python 函数中 , 可以接受零个或多个参数 , 这些参数可以传递到函数中进行操作 ; 函数参数也可…
阅读更多...
Java并发(九)----线程join、interrupt

Java并发(九)----线程join、interrupt

1、join 方法详解 1.1 为什么需要 join&#xff1f; 下面的代码执行&#xff0c;打印 r 是什么&#xff1f; static int r 0; public static void main(String[] args) throws InterruptedException {test1(); } private static void test1() throws InterruptedException …
阅读更多...
用C++ 包装STM32 官方固件库 - 链式调用改写初始化结构体

用C++ 包装STM32 官方固件库 - 链式调用改写初始化结构体

拿C 在固件库上套娃一层有几点原因&#xff1a; 固件库都是用C 写的&#xff0c;而我平时都用C&#xff0c;虽然是兼容的&#xff0c;但C 的一些特性我不喜欢&#xff1b;我不喜欢官方库的函数命名风格&#xff1b;各个厂家的固件库大同小异&#xff0c;但是“小异”的那一部分…
阅读更多...
路径规划算法：基于旗鱼优化的路径规划算法- 附代码

路径规划算法：基于旗鱼优化的路径规划算法- 附代码

路径规划算法&#xff1a;基于旗鱼优化的路径规划算法- 附代码 文章目录 路径规划算法&#xff1a;基于旗鱼优化的路径规划算法- 附代码1.算法原理1.1 环境设定1.2 约束条件1.3 适应度函数 2.算法结果3.MATLAB代码4.参考文献 摘要&#xff1a;本文主要介绍利用智能优化算法旗鱼…
阅读更多...
Direct3D 12——几何——基础

Direct3D 12——几何——基础

在几何里可分为两种几何&#xff0c;一种是显式几何&#xff0c;另外一种是隐式几何。有不同的方式表示不同的几何 隐式几何 隐式实际上是说不会告诉具体的这些点点就在哪&#xff0c;只告诉你这些点满足的关系。表示一定的关系但并不会给实际的点 例子&#xff1a; 隐式几何…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023