变长结构体的表示方法

最新推荐文章于 2023-01-11 10:20:12 发布
最新推荐文章于 2023-01-11 10:20:12 发布
阅读量651 收藏
点赞数
分类专栏： C

变长结构体的表示方法

分类： 编程 2010-08-07 17:31 798人阅读 评论(2) 收藏 举报

转载请注明出处： http://blog.csdn.net/zhangyang0402/archive/2010/08/07/5795614.aspx

 

在Linux程序中，经常会看到形如下面的结构体定义
struct xfrm_algo {
 char  alg_name[64];
 unsigned int alg_key_len;    /* in bits */
 char  alg_key[0]; //有的地方这样写char alg_key[]
};

这里，最奇怪的是结构体最后一个元素, 是一个零长度的字符数组

这里先解释一下结构体的作用。
xfrm_algo是一个定义密钥算法的结构体，alg_name存放算法名称，alg_key_len存放密钥长度(单位是bit)，all_key存放密钥. 因为同一个算法，有可能会使用不同长度的密钥。

如AES， 就有128位、192位和256位三种密钥。 所以，在定义这样一个密钥算法的结构体时，就要求不定长的结构体，而零长数组就可实现这一点。


当然，我们也可以使用指针来代替

struct xfrm_algo {
 char  alg_name[64];
 unsigned int alg_key_len;    /* in bits */
 char *  alg_key;
};

下面，分别用指针和零长数组实现不定长结构体。

方法1:定义一个xfrm_algo结构体变量，再为alg_key成员动态创建内存

这种情况下，实际的xfrm_algo结构体和密钥是分离的

[cpp] view plain copy print ?
  1. #include<stdio.h>   
  2. #include<stdlib.h>   
  3. #include<string.h>   
  4.   
  5. void print_hex( unsigned char *buf, int len);  
  6.   
  7. struct xfrm_algo  
  8. {  
  9.         char             alg_name[64];  
  10.         unsigned int     alg_key_len;  
  11.         unsigned char *  alg_key;  
  12. };  
  13.   
  14. int main( void )  
  15. {  
  16.         char alg[] = "AES";  
  17.         unsigned char key[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, /  
  18.                                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };  
  19.         struct xfrm_algo algo1;  
  20.         memcpy( algo1.alg_name, alg, sizeof(alg) );  
  21.         algo1.alg_key_len = sizeof(key) * 8;  
  22.         if( ( algo1.alg_key = (unsigned char *)malloc( sizeof(key) ) ) == NULL )  
  23.         {  
  24.                 perror("malloc");  
  25.                 return -1;  
  26.         }  
  27.         memcpy( algo1.alg_key, key, sizeof(key) );  
  28.         printf("sizeof(struct xfrm_algo) = %d/n", sizeof(struct xfrm_algo));  
  29.         printf("algo1: 0x%08x/n", &algo1);  
  30.         printf("/talg_name   : 0x%08x(%s)/n", algo1.alg_name, algo1.alg_name);  
  31.         printf("/talg_key_len: 0x%08x(%d)/n", &algo1.alg_key_len, algo1.alg_key_len);  
  32.         printf("/talg_key    : 0x%08x", algo1.alg_key);  
  33.         print_hex( algo1.alg_key, sizeof(key) );  
  34.         free(algo1.alg_key);  
  35.         return 0;  
  36. }  
  37.   
  38. void print_hex( unsigned char *buf, int len)  
  39. {  
  40.         int i = 0;  
  41.         printf("(");  
  42.         for( i = 0; i < len; i++ )  
  43.         {  
  44.                 printf("0x%02x ", buf[i]);  
  45.         }  
  46.         printf(")/n");  
  47. }  

 

执行结果：
$ ./struct_pointer1
sizeof(struct xfrm_algo) = 72
algo1: 0xbff54108
        alg_name   : 0xbff54108(AES)
        alg_key_len: 0xbff54148(128)
        alg_key    : 0x09b2f008(0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f )

从输出可观察到， alg_key_len与alg_key是分离的

 

方法2: 直接为xfrm_algo和已知的密钥动态创建内存

此时，xfrm_algo结构体和密钥是连续的。

[cpp] view plain copy print ?
  1. #include<stdio.h>   
  2. #include<stdlib.h>   
  3. #include<string.h>   
  4.   
  5. void print_hex( unsigned char *buf, int len);  
  6.   
  7. struct xfrm_algo  
  8. {  
  9.         char             alg_name[64];  
  10.         unsigned int     alg_key_len;  
  11.         unsigned char *  alg_key;  
  12. };  
  13.   
  14. int main( void )  
  15. {  
  16.         char alg[] = "AES";  
  17.         unsigned char key[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, /  
  18.                                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };  
  19.         struct xfrm_algo *palgo = NULL;  
  20.         if( ( palgo = (struct xfrm_algo * )malloc( sizeof(struct xfrm_algo) + sizeof(key) ) ) ==  NULL )  
  21.         {  
  22.                 perror("malloc");  
  23.                 return -1;  
  24.         }  
  25.         memcpy( palgo->alg_name, alg, sizeof(alg) );  
  26.         palgo->alg_key_len = sizeof(key) * 8;  
  27.         palgo->alg_key = (unsigned char *)( palgo + 1 );  
  28.         memcpy( palgo->alg_key, key, sizeof(key) );  
  29.         printf("sizeof(struct xfrm_algo) = %d/n", sizeof(struct xfrm_algo));  
  30.         printf("palgo: 0x%08x/n", palgo);  
  31.         printf("/talg_name   : 0x%08x(%s)/n", palgo->alg_name, palgo->alg_name);  
  32.         printf("/talg_key_len: 0x%08x(%d)/n", &palgo->alg_key_len, palgo->alg_key_len);  
  33.         printf("/talg_key    : 0x%08x", palgo->alg_key);  
  34.         print_hex( palgo->alg_key, sizeof(key) );  
  35.         free(palgo);  
  36.         return 0;  
  37. }  
  38.   
  39. void print_hex( unsigned char *buf, int len)  
  40. {  
  41.         int i = 0;  
  42.         printf("(");  
  43.         for( i = 0; i < len; i++ )  
  44.         {  
  45.                 printf("0x%02x ", buf[i]);  
  46.         }  
  47.         printf(")/n");  
  48. }  

 

执行结果:
$ ./struct_pointer2
sizeof(struct xfrm_algo) = 72
palgo: 0x096bd008
        alg_name   : 0x096bd008(AES)
        alg_key_len: 0x096bd048(128)
        alg_key    : 0x096bd050(0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f )

从输出可观察到， alg_key_len与alg_key是连续的。这里，alg_key似乎是多余的，因为我们总能使用(unsigned char *)( palgo + 1 )得到key的首地址。
 
方法3：零长度数组

在标准C语言中，是不允许零长度数组的。但 GNU C 允许。

 

[cpp] view plain copy print ?
  1. #include<stdio.h>   
  2. #include<stdlib.h>   
  3. #include<string.h>   
  4.   
  5. void print_hex( unsigned char *buf, int len);  
  6.   
  7. struct xfrm_algo  
  8. {  
  9.         char             alg_name[64];  
  10.         unsigned int     alg_key_len;  
  11.         unsigned char    alg_key[0];  
  12. };  
  13.   
  14. int main( void )  
  15. {  
  16.         char alg[] = "AES";  
  17.         unsigned char key[] = { 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, /  
  18.                                 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e, 0x0f };  
  19.         struct xfrm_algo *palgo = NULL;  
  20.         if( ( palgo = (struct xfrm_algo *)malloc( sizeof(struct xfrm_algo) + sizeof(key) ) ) ==  NULL )  
  21.         {  
  22.                 perror("malloc");  
  23.                 return -1;  
  24.         }  
  25.         memcpy( palgo->alg_name, alg, sizeof(alg) );  
  26.         palgo->alg_key_len = sizeof(key) * 8;  
  27.         memcpy( palgo->alg_key, key, sizeof(key) );  
  28.         printf("sizeof(struct xfrm_algo) = %d/n", sizeof(struct xfrm_algo));  
  29.         printf("palgo: 0x%08x/n", palgo);  
  30.         printf("/talg_name   : 0x%08x(%s)/n", palgo->alg_name, palgo->alg_name);  
  31.         printf("/talg_key_len: 0x%08x(%d)/n", &(palgo->alg_key_len), palgo->alg_key_len);  
  32.         printf("/talg_key    : 0x%08x", palgo->alg_key);  
  33.         print_hex( palgo->alg_key, palgo->alg_key_len / 8 );  
  34.         free(palgo);  
  35.         return 0;  
  36. }  
  37.   
  38. void print_hex( unsigned char *buf, int len)  
  39. {  
  40.         int i = 0;  
  41.         printf("(");  
  42.         for( i = 0; i < len; i++ )  
  43.         {  
  44.                 printf("0x%02x ", buf[i]);  
  45.         }  
  46.         printf(")/n");  
  47. }  

 


执行结果：

$ ./struct_array
sizeof(struct xfrm_algo) = 68
palgo: 0x0980d008
        alg_name   : 0x0980d008(AES)
        alg_key_len: 0x0980d048(128)
        alg_key    : 0x0980d04c(0x00 0x01 0x02 0x03 0x04 0x05 0x06 0x07 0x08 0x09 0x0a 0x0b 0x0c 0x0d 0x0e 0x0f )

xfrm_algo结构体大小为68个字节， alg_key[0]不占存储空间，和方法1、2相比，少了个unsigned char *指针，但可移植性不比前两种方法。 

rheostat
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
C语言面向方法思想的可变长度数组的动态库
04-23
// 用结构体表示可变长度数组 List* list_init(size_t initial_size); // 初始化数组，指定初始容量 void list_free(List* lst); // 释放数组及其内存 int list_append(List* lst, int value); // 在数组末尾添加...
网络通信中C、C++结构体转C#结构体.rar
10-14
转换完成后，我们可以通过网络发送这个结构体的字节表示，接收端按照相同的方式解析这些字节来恢复原始结构体。 总之，将C/C++的结构体转换为C#结构体涉及到数据类型的映射、内存对齐、序列化和反序列化等多个方面...
可变长结构体
l176266956的专栏
11-18 2002
今天在看tinyxml源码的时候发现了在结构体使用数组长度为1的数据，如下： struct Rep { size_type size, capacity; char str[1]; }; 这是之前没有接触过的，上网了解才知道这主要是为了实现可变长结构体， 下面是自己写的测试代码： #include #include #include struct lvt { s
变长结构体
lvpwin的专栏
06-29 378
typedef struct tagTest{int uID;int iNum;int offsetint data[1]; //可变长数据，根据所需要数据类型定义}Test；data是一个数据，个数为1，但是其实在使用的时候，不一定为1，也就是说在上述结构不能直接Test tmp;这样声明，必要声明成指针，然后在malloc的时候，根据iNum数目进行申请，譬如iNum为5个int，这可以这样p
结构体的四种表示方法
qq_45782978的博客
03-15 1465
转载自https://blog.csdn.net/qq_37271216/article/details/96611887 1. 先定义结构体类型，再定义结构体变量。 struct student{ char no[20]; //学号 char name[20]; //姓名 char sex[5]; //性别 int age; //年龄 }; struct student stu1,stu2; //此时stu1,stu2为student结构体变量 2. 定义结构体类型的同时定义结构体变量。 struct
struct的几种表示方法
So_discrepancy的博客
11-06 392
struct的表示方法
结构体中最后一个数组长度为零
11-07
这种结构体的使用方法是动态分配内存，例如： ```c struct pppoe_tag *sample_tag; __u16 sample_tag_len = 10; sample_tag = (struct pppoe_tag *)malloc(sizeof(struct pppoe_tag) + sizeof(char) * sample_tag_...
winsock收发结构体
05-10
Winsock遵循Berkeley套接字接口标准，使得在Windows平台上开发网络应用变得更加便捷。 在C/S架构中，客户端与服务器之间的通信通常涉及数据的发送和接收。这些数据往往通过特定的数据结构来传递，也就是这里的...
C技巧：结构体参数转成不定参数
08-14
这种情况下，C语言提供了变长参数列表的功能，通常通过`stdarg.h`头文件中的类型和函数来实现。本文将探讨如何将一个接受结构体参数的函数转换为接受可变参数的函数。 首先，了解`stdarg.h`头文件中的关键类型和...
变长数据结构
dadalan的专栏
08-28 2138
struct dirent{..............char a[1];}在这里char a[1];长度为1,一般认为作为字符数组只能存放/0，但在这里a[1]声明是放在结构体的最后，属于变长数据结构的使用，能够方便访问结构体后面的地址，如：[Copy to clipboard] [ - ]CODE:  struct dirent{   int len;   char a[0];};
变长结构体（尾随数据）
人生代码，代码人生。。。
06-22 1008
typedef struct tagTest { int uID; int iNum; int offset; int data[1]; //可变长数据，根据所需要数据类型定义 }Test; data是一个数据，个数为1，但是其实在使用的时候，不一定为1，也就是说在上述结构
深入浅出变长结构体
u012841414的博客
01-11 692
这个时候存储包的时候，一方面可以考虑设定包的大小固定：如4K=4*1024=4096个字节，因为最大包长不可能超过4k，但该方法的有缺陷，存在一种极端就是包最小仅含包头不含数据域，此时包为8个字节，浪费了4096-8 =4088个字节的存储空间。，主要是为了方便的管理内存缓冲区，如果你直接使用指针而不使用数组，那么，你在分配内存缓冲区时，就必须分配结构体一次，然后再分配结构体内的指针一次，（而此时分配的内存已经与结构体的内存不连续了，所以要分别管理即申请和释放）。是的，是可以实现的。
变长结构体的应用
huqinwei的专栏
02-29 3191
顾名思义，结构体长度是“可变”的。但是这个可变不针对sizeof()函数。 用例代码： //弹性数组的大小，各对象是否都不一样？ //如果都一样，怎么看空间大小，用sizeof array来加? //但是如果是对象，也没法看，因为是指针指向对象的形式 //用的时候，申请可以是这样 #include #define ARRAY_SIZE 200 struct S{ int* a; int
一文带你走进Linux内核之XFRM框架
m0_73494896的博客
09-02 1440
XFRM的正确读音是transform(转换), 这表示内核协议栈收到的IPsec报文需要经过转换才能还原为原始报文；同样地，要发送的原始报文也需要转换为IPsec报文才能发送出去。Psec（Internet协议安全）应该很多人都听过，IPsec是一组协议，他们通过对通信会话中的每个数据包进行身份验证和加密，以确保IP流量的安全。XFRM框架是IPsec的“基础设施”，IPsec通过XFRM框架实现的。XFRM源自USAGI项目，该项目旨在提供适用于生产环境的IPv6和IPsec协议栈。
解析变长结构体的用法和优点
Move_now的博客
05-14 6077
变长结构体：在接触变长结构体之前,以为会是一个很难理解的东西,但是这其实算是C里面的一种技巧吧,优点是：分配了一段连续的内存,防止内存碎片化以及方便内存的管理。使用变长结构体的格式如下：struct Test { .... int a; .... char b[0]; }; 重点是结构体的最后一个成员char b[0],是个空数组。在我们不知道结构体内的某个成员大小是多少的时候,我们
Linux内核中的IPSEC实现(1)
dolphin98629的专栏
12-31 4665
Java代码   1. 前言      在Linux2.6内核中自带了IPSEC的实现,这样就不用象2.4那样打补丁来实现了。该实现包括以下几个部分: PF_KEY类型套接口, 用来提供和用户层空间进行PF_KEY通信，代码在net/key目录下，前面已经介绍过；安全联盟SA和安全策略SP管理，是使用xfrm库来实现的，代码在net/xfrm/目录下定义；ESP，AH等协议实现，
C语言中变长的结构体数组如何初始化
最新发布
06-09
在 C 语言中，如果要定义变长的结构体数组，可以先定义一个指向结构体的指针，然后再动态地为该指针分配内存空间，从而实现变长数组的初始化。 下面是一个示例代码： ```c #include <stdio.h> #include <stdlib.h> struct student { char name[20]; int age; }; int main() { int n = 3; struct student *s = (struct student*) malloc(n * sizeof(struct student)); if (s == NULL) { printf("Memory allocation failed.\n"); exit(1); } for (int i = 0; i < n; i++) { printf("Enter name and age for student %d: ", i+1); scanf("%s %d", s[i].name, &s[i].age); } printf("The students' information:\n"); for (int i = 0; i < n; i++) { printf("Name: %s, Age: %d\n", s[i].name, s[i].age); } free(s); return 0; } ``` 在上面的示例代码中，首先定义了一个变量 `n`，表示要创建的结构体数组的长度。然后通过 `malloc()` 函数为指向结构体的指针 `s` 分配内存空间，大小为 `n * sizeof(struct student)`，即结构体的大小乘以数组的长度。接着通过循环为每个结构体成员的 `name` 和 `age` 成员赋值。最后释放已分配的内存空间。 需要注意的是，使用动态内存分配时，需要在程序结束前释放内存，避免内存泄漏。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值