C/C++中如何遍历结构体的元素？

wayne

我现在有一个需求：
已知某人给我提供了 一个动态库，和对应的头文件。头文件里面描述了结构体的各种元素，大概有50多个，元素全是char数组，大小不一。

我现在需要遍历这些元素，把它们join成一个字符串，可有什么便捷的好方法，我该不会一个一个的用操作符 ->取出来吧？  

G-Spider

不知道你说的是什么样的结构体，如果不是指针类型而是已明确了成员的char var[N]; 这种情况下，结构体大小是确定的sizeof ，数据是一片连续内存块，那么就不需要知道各个成员是什么名字。
接下来就是去掉这内存块里面的零值。
最后printf.

wayne

2# G-Spider
有50多个成员，每一个成员都是char var[N], 但每一个成员的N是不一样的，没有规律。
去掉内存块的零值是啥意思，求解释。

G-Spider

3# wayne
偷懒的局限性在代码的注释中

1. #include <stdio.h>
   
2. #include <string.h>
   
3. 
   
4. typedef struct
   
5. {
   
6.     char d0[12];
   
7.     char d1[6];
   
8.     char d2[5];
   
9. }tD,*pD;
   
10. 
    
11. void removezero(char *dst,char *src,int len)
    
12. {
    
13.     char *p=src;
    
14.     int i;
    
15.     for(i=0;i<len;i+=strlen(p)+1)
    
16.     {
    
17.         p=src+i;
    
18.         strcat(dst,p);   
    
19.     }
    
20. }
    
21. 
    
22. void main()
    
23. {
    
24.     pD src=NULL,dst=NULL;
    
25.     src=(pD)malloc(sizeof(tD));
    
26.     dst=(pD)malloc(sizeof(tD));
    
27.     if(NULL==src|| NULL==dst)
    
28.         return;
    
29.     memset(dst,0,sizeof(tD));
    
30.     memset(src,0,sizeof(tD)); /*块需初始化为0*/
    
31.    
    
32.     strcpy(src->d0,"good");
    
33.     strcpy(src->d1,"luck");
    
34.     strcpy(src->d2,"man");
    
35.     /*-------------------join---------------------*/
    
36.     removezero((char *)dst,(char *)src,sizeof(tD));
    
37.    
    
38.     printf("%s\n",dst);
    
39.     system("pause");
    
40. }

复制代码

wayne

4# G-Spider
不错，有点tricky，我知道怎么做了。
我的实际需求其实是把结构体的都是char []的成员用逗号 join 成一个字符串。

===========
BTW，貌似高手都不太喜欢用calloc呢，

1. #include <stdio.h>
   
2. #include <stdlib.h>
   
3. #include <string.h>
   
4. 
   
5. typedef struct {
   
6.     char d0[12];
   
7.     char d1[6];
   
8.     char d2[5];
   
9. } tD,*pD;
   
10. 
    
11. void removezero(char *dst,char *src,int len)
    
12. {
    
13.     char *p=src;
    
14.     int i;
    
15.     for(i=0; i<len; i+=strlen(p)+1) {
    
16.         p=src+i;
    
17.         strcat(dst,p);
    
18.     }
    
19. }
    
20. 
    
21. int main()
    
22. {
    
23.     pD src=NULL,dst=NULL;
    
24.     src=(pD)calloc(1,sizeof(tD));
    
25.     dst=(pD)calloc(1,sizeof(tD));
    
26.     if(NULL==src|| NULL==dst)
    
27.         return 1;
    
28.    // memset(dst,0,sizeof(tD));
    
29.    // memset(src,0,sizeof(tD)); /*彘濮邃负0*/
    
30. 
    
31.     strcpy(src->d0,"good");
    
32.     strcpy(src->d1,"luck");
    
33.     strcpy(src->d2,"man");
    
34.     /*-------------------join---------------------*/
    
35.     removezero((char *)dst,(char *)src,sizeof(tD));
    
36. 
    
37.     printf("%s\n",(char *)dst);
    
38. //    system("pause");
    
39.     return 0;
    
40. }
    

复制代码

G-Spider

修改下removezero逗号分隔

for(...)
{
    p=src+i;
    if(*p)
    {
        strcat(dst,p);
        dst[strlen(dst)]=',';
    }
}
dst[strlen(dst)-1]=0;

gxqcn

4# G-Spider
不错，有点tricky，我知道怎么做了。
我的实际需求其实是把结构体的都是char []的成员用逗号 join 成一个字符串。

===========
BTW，貌似高手都不太喜欢用calloc呢，#include
#include
#inc ...
wayne 发表于 2013-5-14 11:05

以前只知道 malloc/realloc/free，还真没注意到calloc；
刚刚查了下MSDN，alloc 与realloc一样有一个额外动作：分配内存中的一个数组的元素初始化为 0。

alloc 似乎还有一个特殊功能：可得到确保为存储指定对象的内存对齐。
但是，数据对齐现在有了更好的函数：_aligned_malloc / _aligned_offset_malloc / _aligned_free
再加上 memset 函数，即可达到相同目的，且更自由。

G-Spider

5#,哈，主要是用习惯了吧，  malloc的好处是，是否需要初始化memset倒可以放到需要的地方。

郭说的这个分配一个数据对齐的内存，只前尝试大数库的时候倒有体会，也思考了很久，特别是为了有个16字节对齐的内存好SSE的相关处理。

7# 提到的_aligned_malloc /_aligned_free 第一次听到，由于不是标准库里的函数，于是百度了一下想知道其原理，发现与我之前想的一致：
就是多申请一些空间用于保存申请的内存的原地址，以便用于释放。
而保存原地址的位置在对齐边界后p的前一个sizeof(void *)的地方即&p[-1]，里面的值p[-1]为原malloc返回的地址，p是对齐后的地址。

1. #include <stdio.h>
   
2. void* _mm_malloc (size_t size, size_t align)
   
3. {
   
4.     void * malloc_ptr;
   
5.     void * aligned_ptr;
   
6. 
   
7.     /* Error if align is not a power of two.  */
   
8.     if (align & (align - 1))
   
9.     {
   
10.       return ((void*) 0);
    
11.     }
    
12. 
    
13.     if (size == 0)
    
14.         return ((void *) 0);
    
15. 
    
16.     /* Assume malloc'd pointer is aligned at least to sizeof (void*).
    
17.        If necessary, add another sizeof (void*) to store the value
    
18.        returned by malloc. Effectively this enforces a minimum alignment
    
19.        of sizeof double. */     
    
20.     if (align < 2 * sizeof (void *))
    
21.         align = 2 * sizeof (void *);
    
22. 
    
23.     malloc_ptr =(void *)malloc(size + align);
    
24.     if (!malloc_ptr)
    
25.         return ((void *) 0);
    
26. 
    
27.     /* Align  We have at least sizeof (void *) space below malloc'd ptr. */
    
28.     aligned_ptr = (void *) (((size_t) malloc_ptr + align)
    
29.                           & ~((size_t) (align) - 1));
    
30. 
    
31.     /* Store the original pointer just before p.  */      
    
32.     ((void **) aligned_ptr) [-1] = malloc_ptr;
    
33.     return aligned_ptr;
    
34. }
    
35. 
    
36. void _mm_free (void * aligned_ptr)
    
37. {
    
38.     if (aligned_ptr)
    
39.         free (((void **) aligned_ptr) [-1]);
    
40. }
    
41. 
    
42. void main()
    
43. {
    
44.     char *data;
    
45.     /* 没用过[-1]的数组定位方式，测试一下*/
    
46.     char d[4]={'a','b','c','d'};
    
47.     char *p=&d[2];
    
48.     printf("%c\n",p[-1]);
    
49.     /**************************************/
    
50.     data=(char *)_mm_malloc(12,64);
    
51.     printf("%p %08X\n",data,((unsigned int *)data)[-1]);
    
52.     _mm_free(data);
    
53.    
    
54. }

复制代码