网络数据是以流的形式进行传输的（我们在构造客户端/服务端待发送数据时，肯定有特定的格式）。

关于发送一次，一个包的完整性可靠接收（tcp的可靠传输，以及取数据的半包粘包问题）这里不关注，可以参考上文。

这里的目的是：

===》备份c语言字符处理相关方案

===》备份自己在业务实现时，对字符串切割实现的一个接口（strstr，strcasestr，strsep，strtok，strdup相关接口）

有如下几个细节可以关注：

===》1：实现不同类型的数据拼接字符串的方案 （3.1）

===》2：char**通过传参的方式再函数内部进行构造（3.2.4.2）

===》3：对字符串进行解析处理的几种方案，尤其是分割字符串的实现（strsep实现了demo）（3.2.4）

1：背景描述

网络传输过程中，如tcp的客户端可服务端进行通信时，send函数实际发送的数据是用字符数组+长度表示的，即流的形式。

有关一次发送，一个包的完整接收，依赖于tcp底层的可靠流式传输，需要进行半包和粘包处理，可以参考上文。

但是，这里针对一个包的结构，我们其实也会需要根据我们的业务场景进行设计，按照特定的结构进行构造，与解析。

这里关注一次发送一个包的构造与解析方案，以及代码实现做备份

2：逻辑描述

2.1：大概描述

网络传输中，对字符流的处理非常重要，建立在我们制定的特定的规范上

===》除了关注一个包的完整接收（粘包半包问题），还需要关注数据本身

===》1：类似tcp/ip协议栈那样，用特定的协议栈，特定的字节表示特定的含义进行解析（固定字节大小表示含义）

===》2：我们可以自定义规范，如用特定的字符/字符串进行识别，分割不同字符所表示的含义（如 msg_type|other_type|msg_len|msg_data）.

这里针对以上所描述的两种方案的数据的构造与解析，进行梳理及代码测试。。。

2.2：数据的构造（目的构造特定格式待发送的char*及获取长度）

一般发送端和接收端对数据的处理都是协商好的，按照特定的格式构造，必然会按照特定的格式进行解析。

数据的构造本质：其实就是按照特定的格式给char指针中塞入协商的格式的数据，以及获取到实际发送的数据的长度。

===》1：类似tcp/ip协议头，可以通过结构体指针强转，以及获取实际长度进行发送

===》2：构造要发送的char*指针及获取长度方案：使用 memcpy

===》3：构造要发送的char*指针及获取长度方案：c库函数，strcpy, strcat

===》4：构造要发送的char*指针及获取长度方案：使用sprintf、sprintf_s （觉得最好用）

2.3：数据的解析（目的对接收到的char*按协商的格式进行解析）

以流的形式，接收到对待的数据（实际是char*指针和数据长度），对其按照协商进行解析。

解析的本质：按照特定的字节，或者对整个流进行处理依次取特定位置数据

===》1：指针强转，类似tcp/ip协议栈处理，可以把接收到的报文，直接转为结构体指针进行操作

===》2：先取特定长度，再按这个长度取实际数据。（发送先发送长度+data（可以自己定义解析格式））

===》3：解析接收到的流，进行解析（如按照“|”进行分割）

本文的目的之一也是为了备份按照“|”进行分割的一个实践代码

3：代码梳理

3.1：待发送数据构造的demo

3.1.1：结构体指针转为char*实现/解析逻辑

构造结构体，计算实际长度，send时直接转为char*传参进行发送。。。

再linux环境上使用gcc进行编译测试过，代码执行ok

//1：类似tcp/ip协议栈，其实都是按照特定的结构体进行类型强转数据解析
void parse_struct_format_data()
{printf("parse_struct_format_data test: \n");//假设定义了柔性数组，构造数据并解析数据的流程如下struct my_data_t{int msg_type;int data_len;char data[0];};//假设要发送的数据为client send data example. \n， 类型为1const char* data = "client send data example. \n";//发送端构造最终的数据如下struct my_data_t *send_data = NULL;send_data = (struct my_data_t*)malloc(sizeof(struct my_data_t)+strlen(data)+1);if(send_data == NULL){return ;}memset(send_data, '\0', sizeof(struct my_data_t)+strlen(data)+1);//只是预留了一个位而已send_data->msg_type = 1;send_data->data_len = strlen(data);memcpy(send_data->data, data, strlen(data));//这里其实 send_data就是我们最终构造的一个网络数据格式包，可以进行发送//使用send进行发送时，只是传参char*以及待发送的数据长度char *send_para_data = (char *)send_data; //结构体类型强转  tcp识别到的是这个结构里的流数据int send_para_data_len = sizeof(struct my_data_t)+strlen(data);//如果客户端使用send_para_data 及长度send_para_data_len 进行发送及校验 。。。//我们收到的流，以recv进行接收，就是一个字符流，内容其实就是send_para_data 长度为send_para_data_len //这里要完整的接收到一个包（半包粘包问题，可参考上文）//进行逆向解析就好struct my_data_t *recv_data = (struct my_data_t*)send_para_data;//可以按照柔性数组的逻辑 按照长度对实际数据进行解析打印printf("\trecv_data type is [%d] \n",recv_data->msg_type);printf("\trecv_data len is [%d] \n",recv_data->data_len);//这里只是测试  注意如果这个data中有特殊的字符如\0等，不能这样打印，要按照十六进制按照长度打印printf("\trecv_data len is [%s] \n", recv_data->data);printf("recv_data ASSII is [");for(int i=0; i<recv_data->data_len; i++){printf("%02x ", recv_data->data[i]);}printf("]\n");if(send_data!= NULL){free(send_data);send_data = NULL;}
}

3.1.2：使用memcpy实现字符串的拼接，构造char*

目的是获得最终的char*指针位置以及实际发送的数据长度。

这里因为懒，使用了to_string把int转为string进行测试，所以编译的时候用c++11，可以修改用itoa…

//1:使用memcpy实现字符串的拼接 splicing test of string1 and string2
int use_memcpy_splic_string()
{
printf("use_memcpy_splic_string test:\n");const char* str1 = "splicing test of ";const char* str2 = "string";const char* and1 = " and ";int one = 1;int two = 2;//这里用到了C++中的to_string函数  c语言可以用itoa,这里主要是理解字符串拼接，，， 有int类型的字符串转换拼接常用sprintfint size = strlen(str1) + strlen(str2) * 2 + (strlen(to_string(one).c_str())) + strlen(and1) + (strlen(to_string(two).c_str())) + 1;printf("\tget the len is : %d %lu\n", size, strlen("splicing test of string1 and string2"));int pos = 0;char* result = (char*)malloc(size);if (result == NULL){return -1;}memset(result, '\0', size);memcpy(result, str1, strlen(str1));pos += strlen(str1);memcpy(result + pos, str2, strlen(str2));pos += strlen(str2);memcpy(result + pos, to_string(one).c_str(), strlen(to_string(one).c_str()));pos += strlen(to_string(one).c_str());memcpy(result + pos, and1, strlen(and1));pos += strlen(and1);memcpy(result + pos, str2, strlen(str2));pos += strlen(str2);memcpy(result + pos, to_string(two).c_str(), strlen(to_string(two).c_str()));pos += strlen(to_string(two).c_str());printf("\tthe result is [%lu][%s]  \n", strlen(result), result);printf("\tpos is [%d] \n", pos);if (result != NULL){free(result);result = NULL;}return 0;
}

3.1.3：使用c库函数（strcpy， strcat）

偷懒用了to_string(),编译测试用c++11

//2:使用c库函数实现字符串的拼接 splicing test of string1 and string2
//写代码的时候要注意目标字符串的长度一定要够用
int use_clibrary_strcat_splic_string()
{printf("use_clibrary_strcat test: \n");const char* str1 = "splicing test of ";const char* str2 = "string";const char* and1 = " and ";int one = 1;int two = 2;//这里用到了C++中的to_string函数  c语言可以用itoa,这里主要是理解字符串拼接，，， 有int类型的字符串转换拼接常用sprintfint size = strlen(str1) + strlen(str2) * 2 + (strlen(to_string(one).c_str())) + strlen(and1) + (strlen(to_string(two).c_str())) + 1;printf("\tget the len is : %d %lu\n", size, strlen("splicing test of string1 and string2"));char* result = (char*)malloc(size);if (result == NULL){return -1;}memset(result, '\0', size); //vs上测试时要用strcpy_s// strcpy_s(result, size, str1);// strcat_s(result, size, str2);// strcat_s(result, size, to_string(one).c_str());// strcat_s(result, size, and1);// strcat_s(result, size, str2);// strcat_s(result, size, to_string(two).c_str());//注意字符串处理时的不安全性！！！strcpy(result,  str1);strcat(result,  str2);strcat(result,  to_string(one).c_str());strcat(result,  and1);strcat(result,  str2);strcat(result,  to_string(two).c_str());printf("\tthe result is [%lu][%s]  \n", strlen(result), result);if (result != NULL){free(result);result = NULL;}return 0;
}

3.1.4：使用sprintf（sprintf_s）:最实用和方便

vs上测试时需要使用sprintf_s

int use_sprintf_splic_string()
{printf("use_sprintf_splic_string test: \n");const char* str1 = "splicing test of ";const char* str2 = "string";const char* and1 = " and ";int one = 1;int two = 2;//定义目标字符串，为其申请内存都是必须的int size = strlen(str1) + strlen(str2) * 2 + (strlen(to_string(one).c_str())) + strlen(and1) + (strlen(to_string(two).c_str())) + 1;printf("\tget the len is : %d %lu\n", size, strlen("splicing test of string1 and string2"));char* result = (char*)malloc(size);if (result == NULL){return -1;}memset(result, '\0', size);//使用sprintf一步到位sprintf(result, "%s%s%d%s%s%d", str1, str2, one, and1, str2, two);//sprintf_s(result, size, "%s%s%d%s%s%d", str1, str2, one, and1, str2, two);printf("\tthe result is [%lu][%s]  \n", strlen(result), result);if (result != NULL){free(result);result = NULL;}return 0;
}

3.2：接收数据进行解析的demo

3.2.1：直接把char*转为结构体（类似tcp/ip协议栈处理）

参考3.1.1

3.2.2：按照协商的自己含义，使用memcpy按字节处理

参考3.1.2

3.2.3：先接收长度，再接收数据的解析

网络数据有个场景，可以先发送实际数据的长度，recv时先接收特定字节长度，再接收实际数据，保证报的完整.

//2：特定字节表示长度，对后面的数据进行处理==》其实和结构体格式差不多，柔性数组
void parse_len_and_data_networkdata()
{printf("parse_len_and_data_networkdata test: \n");//在网络传输中，可以用特定字节表示长度+实际数据的格式const char *send_data = "msg_type | msg_len |msg_data ...\n"; //实际数据有特殊字符的话，长度要传进来或者结构体其他方案//在网络发送中，如果想简单实现不想用结构那么麻烦，可以这样用 int send_len = strlen(send_data);printf("\tsend_len [%d][%s] \n",send_len, send_data);//可以类似上个函数用结构体  struct data_t{int len; char data[0];};构造//我试试这种：char * real_send_data = (char *)malloc(send_len +4+1);memset(real_send_data, 0, send_len +4+1);memcpy(real_send_data, (char*)&send_len, sizeof(int)); //前四个字节拷贝长度,也可以以字符串形式直接存进去 to_string(send_len).c_str()memcpy(real_send_data +sizeof(int), send_data, send_len);//real_send_data 就是我们实际send的流   我们可以先接收取前四个字节获取数据长度，再接收后面的字段//先定义一个int，从recv取四个字节，转为int表示的长度int recv_len = *(int *)real_send_data; //先recv取四个字节  解析成真正的数据char* recv_data = real_send_data+4;  //这里应该是recv读出来的 长度为recv_len printf("\trecv_len[%d] [%s] \n",recv_len, recv_data);if(real_send_data != NULL){free(real_send_data);real_send_data = NULL;}
}

3.2.4：如果是按字符串进行分割的设计，对其进行解析

这里只是实现了切割字符串的其中一种方案。

3.2.4.1：数据的构造（符合”|“切割的字符串：”msg_type|other_type|msg_len|msg_data“）：

//模拟一个完整的包，返回一个符合特定格式的拼接起来的包数据
//假设 msg_type|other_type|msg_len|msg_data 格式
int get_concatenate_strings(char ** result_data, int* len)
{// 假设格式msg_type|other_type|msg_len|msg_data 格式const char * data = "mytest of spilt of send data ... \n\t test";//注意网络数据这里的复杂，用memcpy处理int msg_type = 1;int other_type = 2;int msg_len = strlen(data); //实际后面的数据长度//这里估算一下最终最大长度 用20+strlen(data)肯定够用char *send_data = NULL;send_data = (char*)malloc(20+msg_len);memset(send_data, 0, 20+msg_len);sprintf(send_data, "%d|%d|%d|", msg_type, other_type, msg_len);//通过传参的方式传递出去*len = strlen(send_data) +msg_len;memcpy(send_data+strlen(send_data), data, msg_len);*result_data = send_data;printf("\t result_data is [%d][%s] \n",*len, send_data);
}

3.2.4.2：按特定字符对字符串实现切割解析（解析提取”msg_type|other_type|msg_len|msg_data“各字段含义）

这里可以关注一下这几个库函数实现字符串切割的方案，测试只是其中一种

char * strstr(const char *haystack, const char *needle); 函数定位子串的位置，然后实现字符串的切割
char * strcasestr(const char *haystack, const char *needle); 和strstr同样的功能，只是忽略两个参数的大小写
char *strtok(char *str, const char *delim); 分解字符串 str 为一组字符串，delim 为分隔符
char *strsep(char **stringp, const char *delim); strtok的升级,

//这里使用"|"对长度为len目标数据data进行切割，通过参数result返回解析后的数据
int check_recv_data_by_spilit(const char * data, int len, char **result, const char* delim)
{//直接根据'|'对字符串进行切割 根据切割后的个数进行校验char *src = strdup(data); //复制了一份数据 strsep会修改原字符串char * src_free = src; //msg_type|other_type|msg_len|msg_data  按照协商的格式 定义了暂存的指针char * delim_buff[4] = {0};char* token = NULL;  //切割后返回的字符指针int i = 0;             //切割的个数//返回的是符合的分割的字符   同时原字符从分割后的位置开始for(token = strsep(&src, delim); token!=NULL && i<4; token=strsep(&src, delim)){delim_buff[i++] = token;printf("\tspilt data [%d:%lu:%s] \n", i, strlen(token), token);printf("\t\t src:[%s] \n",src);}if(i != 4) //必然是协商的格式 {printf("\tvps spilit data error \n");free(src_free);return -1;}int msg_type = (int)atoi(delim_buff[0]);int dev_type = (int)atoi(delim_buff[1]);int data_len = (int)atoi(delim_buff[2]);char * cli_data = delim_buff[3];printf("\nmsg_type:%d, dev_type:%d, data_len:%d:%lu:[%s] \n", msg_type, dev_type, data_len, strlen(cli_data), cli_data);//把解析后的数据进行处理 使用传参传出去int ret = 0;struct client_recv_t *result_t = NULL;result_t = (struct client_recv_t *)malloc(sizeof(struct client_recv_t) + data_len+1);if(result_t == NULL){printf("malloc error \n");*result = NULL;ret = -1;}else{memset(result_t, sizeof(struct client_recv_t) + data_len+1, 0);result_t->msg_type = msg_type;result_t->dev_type = dev_type;result_t->data_len = data_len;memcpy(result_t->data, cli_data, data_len);*result = (char *)result_t;}memset(src_free, 0, len);free(src_free);src_free = NULL;return ret;
}

3.2.4.2：测试代码：

再linux环境直接用gcc进行编译测试，代码ok。。。

//定义一个保存解析后数据的结构
struct client_recv_t
{int msg_type;int dev_type;int data_len;char data[0];
};int parse_spilt_string_and_getdata(const char * data, int len)
{printf("\tneed parse data is [%d][%s] \n", len, data);//使用特定字符串对字符串进行切割，这里举例是"|"，可以是其他的字符串。。。//协商的协议是：msg_type|other_type|msg_len|msg_data //实际数据是：[47][1|2|40|mytest of spilt of send data ... \n\t testchar * result_data_t = NULL; //存储解析后的数据，也可以是其他方案，这里只是举例//这里使用"|"对长度为len目标数据data进行切割，通过传参获取 result_data_tif(check_recv_data_by_spilit(data, len, &result_data_t, "|") != 0){printf("vps parse spilit error \n");return -1;}//对解析后的数据进行打印struct client_recv_t *result_data = (struct client_recv_t *)result_data_t;printf("\t parse test data is [%d][%d][%d][%s] \n", result_data->msg_type, result_data->dev_type, result_data->data_len, result_data->data);// memset(result_data, sizeof(struct client_recv_t)+ (result_data->data_len+1), 0);if(result_data != NULL){free(result_data);result_data = NULL;printf("free success \n");}return 0;
}//真正的入口
void parse_string_spilt_data()
{printf("parse_string_spilt_data test: \n");//假设协商的协议是msg_type|other_type|msg_len|msg_data //构造一个数据,获取到最终发送的数据和数据长度char * send_data = NULL;int send_len = 0;if(get_concatenate_strings(&send_data, &send_len) < 0){printf("\t make send_data error \n");return;}printf("\t last_result_data is [%d][%s] \n",send_len, send_data);//假设对这个数据进行发送了，报的完整性参考上文//接收其实就是这样格式的数据，解析一下这个 这里recv接收时要关注包的完整性parse_spilt_string_and_getdata(send_data, send_len);if(send_data != NULL){free(send_data);send_data = NULL;}
}

我开始试着积累一些常用代码：自己代码库中备用

我的知识储备更多来自这里，推荐你了解：Linux，Nginx，ZeroMQ，MySQL，Redis，fastdfs，MongoDB，ZK，流媒体，CDN，P2P，K8S，Docker，TCP/IP，协程，DPDK等技术内容，立即学习

知识巩固源码落实之6：c语言拼接字符串与切割字符串（strsep）代码相关推荐

知识巩固源码落实之3：缓冲区ringbuffer
1:背景介绍: 在日常业务开发中,使用缓冲区进行临时存储的业务场景也比较多,如tcp每个连接底层都维持一个发送缓冲区和接收缓冲区. 实现一个ringbuffer,做代码备用.(可以考虑如何对ringb ...
知道系统源码/知识问答系统源码/完整PC+手机端带功能强大后台管理系统
仿百度知道系统源码,知识问答系统源码,带有完整的PC端.手机端界面,功能强大后台管理,非常适用于垂直问答社区类行业网站使用. 阿国简单测试了一下,系统功能比较完善,界面部门需要简单优化一下,整体还是很 ...
知识付费源码|知识付费网站搭建|知识付费小程序源码
设计一个在线教育知识付费源码系统(面向对象设计). 解决方案:假设我们想要设计一个基本的内容付费阅读系统并带小程序,提供以下功能: •查找知识数据库并阅读付费内容: •用户成员的创建和扩展: •基于用 ...
java计算机毕业设计知识管理系统源码+数据库+系统+lw文档
java计算机毕业设计知识管理系统源码+数据库+系统+lw文档 java计算机毕业设计知识管理系统源码+数据库+系统+lw文档本源码技术栈: 项目架构:B/S架构开发语言:Java语言开发软件: ...
JAVA计算机毕业设计基于web的面向公众的食品安全知识系统源码+数据库+系统+lw文档
JAVA计算机毕业设计基于web的面向公众的食品安全知识系统源码+数据库+系统+lw文档 JAVA计算机毕业设计基于web的面向公众的食品安全知识系统源码+数据库+系统+lw文档本源码技术栈: 项目 ...
java计算机毕业设计基于web的面向公众的食品安全知识系统源码+数据库+系统+lw文档+mybatis+运行部署
java计算机毕业设计基于web的面向公众的食品安全知识系统源码+数据库+系统+lw文档+mybatis+运行部署 java计算机毕业设计基于web的面向公众的食品安全知识系统源码+数据库+系统+lw ...
spark最新源码下载并导入到开发环境下助推高质量代码(Scala IDEA for Eclipse和IntelliJ IDEA皆适用）（以spark2.2.0源码包为例）（图文详解）...
不多说,直接上干货! 前言其实啊,无论你是初学者还是具备了有一定spark编程经验,都需要对spark源码足够重视起来. 本人,肺腑之己见,想要成为大数据的大牛和顶尖专家,多结合源码和操练编程. ...
重言式判别c语言中文网,重言式判别重言式判别源码及课程设计 c语言版.doc
重言式判别重言式判别源码及课程设计 c语言版重言式的判别题目: 一个逻辑表达式如果对于其変元的任一种取值都为真,则称为重言式:反之,如果对于其变元的任一种取值都为假,则称为矛盾式:然而,更多的情 ...
价值4500的国际版多语言点赞抖音分享点赞任务平台源码（十二种语言）
介绍: 平台会员分享给我的,他自己搭建成功了,测试可用!我就不测试了,需要的拿! 九种语言 :西班牙语,泰语.日语,印度尼西亚语言.越南语言.英文.繁体中文,简体中文,印度语前台支持更换5种颜色风格 ...

知识巩固源码落实之6：c语言拼接字符串与切割字符串（strsep）代码