[原创]在C语言数组初始化中放入任意数据类型

takashiki

版权所有，使用随意。

我们经常在其他编程语言中看到数组初始化内容时，里面的内容参差不齐，而且数据类型千奇百怪，所以用C的也想获取这项便利，然而C89根本不支持，很是烦人。
先来个例子，JavaScript的：

1. var arr = [ 1, '2', Math.sin, false, 0.4, null, [1, 2, 3], ['8', 'this', Object] ];

复制代码

然后就是C89的数组初始化了，可以这样：

1. int arr[] = {1, 2, 3, 4};

复制代码

然而现在我在做液晶屏显示，做了一个菜单，有主菜单，不知道多少项。主菜单还有子菜单，同样不知道多少项。现在简单点，就写菜单标题吧，于是这样写：

1. const char* MenuItems[][] = {
   
2.     {
   
3.         "New", "Open", "Save", "Exit"
   
4.     },
   
5.     {
   
6.         "About"
   
7.     }
   
8. };

复制代码

编译，报错。C语言的数组必须在编译期就能够确定大小，一维数组编译器还能算出来，二维的就傻眼了。

终于，过了好多好多年，估计程序猿的呼声终于有了回应了，于是GCC就有解决方案了，然后C99标准化了。然而，20年过去了，还是好多人不知道。C99说，这点小问题能难住我吗，不知道大小就变成指针啊。于是变成这样：注意，必须开启C99或GNU编译选项，用到了复合字面量。

1. const char** MenuItems[] = {
   
2.     (const char*[]){
   
3.         "New", "Open", "Save", "Exit"
   
4.     },
   
5.     (const char*[]){
   
6.         "About"
   
7.     }
   
8. };

复制代码

然而，细心的朋友会发现，这里居然只有子菜单的菜单项，主菜单的居然不见了！解决方案也简单啊，每一个主菜单做成一个结构体，不就好了？像这样：

1. struct MainMenuItem {
   
2.     const char* Title;
   
3.     const char* Children[];
   
4. };

复制代码

完美解决！

然而，现在无良老板又要我们加了三级菜单，又得改结构，干脆加入链表。
过了几天，无良老板说，子菜单中不但要有菜单名，还要菜单分隔符，还要菜单Action（好吧，这个Delphi中偷来的概念，就当做一个函数吧），而且顺序不定，要是每个菜单项都用一个超大的结构体容纳，占用空间不说，写起来还超级费事，就算码农是搬砖的，那力气也是有限的对不。

终于还是有人看不下去了，开始华丽的魔法，透明联合体！注意，下面的代码如果C99不管用，那就还是开启GNU选项吧。
先声明一个联合体类型，有用没有的全往里面塞。当然了，这个类型占用了最大的成员size。

1. typedef union _ANY {
   
2.     int Int;
   
3.     float Float;
   
4.     char Char;
   
5.     char* String;
   
6.     int* IntArray;
   
7.     void (*Function)();
   
8.     union _ANY* pAny;
   
9. } Any;

复制代码

然后范例来了，初始化往里面填内容，啥都往里装，当然看起来一点都不好看，那个链表甚至编译都有警告，我也不知道怎样消除，反正能正常运行，程序猿是不管警告的。

1. const Any any[] = {
   
2.     1, 1.2f, 'a', (Any)"Hello", (Any)(int[]){1, 2, 3, 4}, (Any)SystemInit,
   
3.     (Any[]) {
   
4.         2, 2.4f, 'b', (Any)"World", (Any)(int[]){5, 6, 7, 8}, (Any)SystemInit,        
   
5.     }
   
6. };

复制代码

myxiaonia

我竟然看不懂
const char** MenuItems[] = {
    (const char*[]){
        "New", "Open", "Save", "Exit"
    },
    (const char*[]){
        "About"
    }
};
这是什么操作，是什么意思

Excellence

w282529350

感觉这种太过于追求技巧的程序不怎么好接手

takashiki

myxiaonia 发表于 2018-11-30 07:52
我竟然看不懂
const char** MenuItems[] = {
    (const char*[]){

复合字面量啊，我在上面说过了。请参考C99或GCC关于这方面的描述。如果你的编译器在这里编译不过去，请再次强制转换一次，变成(const char**)(const char*[]) { }。然后你亲自在IDE中操作一下，就明白啦

jiege0119

myxiaonia 发表于 2018-11-30 07:52
我竟然看不懂
const char** MenuItems[] = {
    (const char*[]){

const char*[] pNOSE = { "New", "Open", "Save", "Exit" };
const char*[] pAbout = { "About" };

const char** MenuItems[] = {
   pNOSE ,
   pAbout
};

我的理解大概是这样的；

xf331785508

你那union是怎么应运的呢？  联合体变量写了一堆，但最后内存里不就是一个末尾的指针吗？其它不是应该全被覆盖了？

chenliangliang_

这是个坑，还是慢慢垒码吧

myxiaonia

jiege0119 发表于 2018-11-30 08:55
const char*[] pNOSE = { "New", "Open", "Save", "Exit" };
const char*[] pAbout = { "About" };

你这一解释为有点明白了，而且正如你所说，这个数组初始化的时候其实产生了3个数组，分别是MenuItems，pNOSE，pAbout ，后两个是匿名的，只能通过MenuItems[0]，MenuItems[1]来访问

这个确实需要扩展了，不是标准c做法

takashiki

myxiaonia 发表于 2018-11-30 09:20
你这一解释为有点明白了，而且正如你所说，这个数组初始化的时候其实产生了3个数组，分别是MenuItems，pN ...

标准C99语法，怎么算是扩展呢。

takashiki

xf331785508 发表于 2018-11-30 09:11
你那union是怎么应运的呢？  联合体变量写了一堆，但最后内存里不就是一个末尾的指针吗？其它不是应该全被 ...

透明联合体，无需指定具体是哪一个字段，编译器自动对应，存的不是末尾的指针哦。
这个GCC是支持的，C99标准里也有但是不见得编译器支持。

zcllom

这个太烧脑，某天想起来再来理解。

RAMILE

富翁式编程思维，一个变量至少占8byte                                 

albert_w

要我想的话, 菜单文字统一放起来. 每个节点类型一样的结构体. 标记兄弟姐妹子节点, 搞个树

ztrx

三级菜单范例能来个吗

ALUMEI

没搞懂那个联合体在这里充当什么角色？

foxpro2005

xf331785508 发表于 2018-11-30 09:11
你那union是怎么应运的呢？  联合体变量写了一堆，但最后内存里不就是一个末尾的指针吗？其它不是应该全被 ...

估计你没看清楚，any[]是Any类的一个数组哇
const Any any[] = {

takashiki

ztrx 发表于 2018-11-30 10:59
三级菜单范例能来个吗

直接给个简单范例，简单的：

1. ttypedef struct _MENUITEM {
   
2.     const char* Text;
   
3.     const struct _MENUITEM* Children;
   
4.     void (*OnMenuClick)( struct _MENUITEM* );
   
5. } MenuItem_t;
   
6. 
   
7. const MenuItem_t MenuItems[] = {
   
8.     {    // 文件菜单项
   
9.         "文件",
   
10.         (MenuItem_t[]){
    
11.             {
    
12.                 "新建",
    
13.                 (MenuItem_t[]){
    
14.                     {"新建文本文件", NULL /* 还可以继续写，想写多长写多长 */, miNewTextClick},
    
15.                     {"新建Word文件", NULL, miNewDocClick},
    
16.                     {"新建Excel文件", NULL, miNewXlsClick},
    
17.                 },               
    
18.             },
    
19.             {"打开文件", NULL, miOpenClick},
    
20.             {"退出", NULL, miExitClick},
    
21.         }
    
22.     },
    
23.     {    // 关于
    
24.         "关于",
    
25.         (MenuItem_t[]){
    
26.             {"关于本程序", NULL, miAboutClick}
    
27.         }
    
28.     }
    
29. };

复制代码

huangqi412

myxiaonia 发表于 2018-11-30 07:52
我竟然看不懂
const char** MenuItems[] = {
    (const char*[]){

看着像二维指针数组

huangqi412

takashiki 发表于 2018-11-30 08:45
复合字面量啊，我在上面说过了。请参考C99或GCC关于这方面的描述。如果你的编译器在这里编译不过去，请再 ...

https://www.amobbs.com/forum.php?mod=viewthread&tid=5703032&extra=page%3D1&mobile=2&_dsign=e080a694
看起来楼主是回答这个贴

takashiki

huangqi412 发表于 2018-11-30 12:18
https://www.amobbs.com/forum.php?mod=viewthread&tid=5703032&extra=page%3D1&mobile=2&_dsign=e080a69 ...

这个贴也是我回答的，而且我还这个坛子至少还回答过两次这样的问题。
但是，透明联合这个我没有回答过，也没有人问过。只是看着C这种强类型（算不那么强的次强类型？）语言表达能力没有很多脚本语言随意书写的方便而发的，带来的后果就是一堆强制转换，很难看。

canspider

新的语法糖
原来需要写一个中间数组来中转
现在用复合字面量少写一个中间数组，由编译器自己分配
非常适合菜单这类程序
如果按照传统写法，要写一堆别的地方用不到的中转数组

jlhgold

takashiki 发表于 2018-11-30 11:37
直接给个简单范例，简单的：

这种如何printf？

takashiki

jlhgold 发表于 2018-11-30 19:29
这种如何printf？

你要printf哪一项？比如"新建Word文件"这个吧：

1. printf("%s", MenuItems[0].Children[0].Children[1].Text);

复制代码

jlhgold

takashiki 发表于 2018-11-30 19:34
你要printf哪一项？比如"新建Word文件"这个吧：

你这个
    void (*OnMenuClick)( struct _MENUITEM* );
这个是如何定义的？感觉有点怪，这个链表看着很费劲啊，

sbusr

二维数组初始化，必须要给列数啊，就是第二个[]

takashiki

jlhgold 发表于 2018-11-30 19:47
你这个
    void (*OnMenuClick)( struct _MENUITEM* );
这个是如何定义的？感觉有点怪，这个链表看着很 ...

这个是函数指针

takashiki

sbusr 发表于 2018-11-30 20:17
二维数组初始化，必须要给列数啊，就是第二个[]

没关系，把里面的那个退化成指针后就不用给出列数了，或者干脆全都退化成指针。只是退化后，sizeof就没法用了，用了得到的也不是自己预期的值；但是下标还是可以用的

lovecxm

虽然看不懂，但还是觉得很神奇，楼主牛，mark

myxiaonia

takashiki 发表于 2018-11-30 08:45
复合字面量啊，我在上面说过了。请参考C99或GCC关于这方面的描述。如果你的编译器在这里编译不过去，请再 ...

受教了。。。又学习了新知识

技术宅

首先这样很费RAM，第二这样很难理解，对后面维护的人来说可能比较吃力，第三也是最重要的，一大堆告警无法接受

takashiki

技术宅 发表于 2018-12-26 15:54
首先这样很费RAM，第二这样很难理解，对后面维护的人来说可能比较吃力，第三也是最重要的，一大堆告警无法 ...

第一，费RAM从何说起。
第二，不是更好理解吗，好多动态语言数据就是这么干的。
第三，把警告关了就好了，作为程序员，不用关心警告，好了，开玩笑的。不用那个链表是没有警告的。

lhaoyue

这个有点烧脑，暂时没理解了

lhaoyue

这个有点烧脑，暂时没理解了

rube

楼主

laoshuhunya

技术宅 发表于 2018-12-26 15:54
首先这样很费RAM，第二这样很难理解，对后面维护的人来说可能比较吃力，第三也是最重要的，一大堆告警无法 ...

警告可以消除，对于有严重强迫症的嵌入式工程师，绝对是不能容忍任何警告的：




类型及全局变量声明/定义：

1. typedef union AnyUnionTag {
   
2.   int   Int;
   
3.   float Float;
   
4.   char  Char;
   
5.   char  *pString;
   
6.   int   *pIntArray;
   
7.   void  (*pFunction)(void);
   
8.   union AnyUnionTag *pAnyUnion;
   
9. } AnyUnionType;
   
10. 
    
11. const AnyUnionType AnyUnionVariable1 = {
    
12.   .Int = 1,
    
13.   .Float = 1.2f,
    
14.   .Char = 'a',
    
15.   .pString = "Hello",
    
16.   .pIntArray = (int []){1, 2, 3, 4},
    
17.   .pFunction = SystemInit,
    
18.   .pAnyUnion = &(AnyUnionType){.Int = 2, .Float = 2.4f, .Char = 'b', .pString = "World", .pIntArray = (int []){5, 6, 7, 8}, .pFunction = SystemInit}
    
19. };
    
20. 
    
21. const AnyUnionType AnyUnionVariable2 = {
    
22.   .Int = 1,
    
23.   .Float = 1.2f,
    
24.   .Char = 'a',
    
25.   .pString = "Hello",
    
26.   .pIntArray = (int []){1, 2, 3, 4},
    
27.   .pFunction = SystemInit,
    
28.   .pAnyUnion = &(AnyUnionType){.Int = 2, .Float = 2.4f, .Char = 'b', .pString = "World", .pIntArray = (int []){5, 6, 7, 8}, .pFunction = SystemInit}
    
29. };

复制代码

局部变量声明/定义：

1.       AnyUnionType AnyUnionArray3[] = {
   
2.         ((AnyUnionType){.Int = 1},
   
3.          (AnyUnionType){.Float = 1.2f},
   
4.          (AnyUnionType){.Char = 'a'},
   
5.          (AnyUnionType){.pString = "Hello"},
   
6.          (AnyUnionType){.pIntArray = (int []){1, 2, 3, 4}},
   
7.          (AnyUnionType){.pFunction = SystemInit},
   
8.          (AnyUnionType){.pAnyUnion = (AnyUnionType *)AnyUnionArray3}),
   
9.          
   
10.         ((AnyUnionType){.Int = 2},
    
11.          // (AnyUnionType){.Float = 2.4f},
    
12.          (AnyUnionType){.Char = 'b'},
    
13.          (AnyUnionType){.pString = "World"},
    
14.          (AnyUnionType){.pIntArray = (int []){5, 6, 7, 8}},
    
15.          (AnyUnionType){.pFunction = SystemInit},
    
16.          (AnyUnionType){.pAnyUnion = (AnyUnionType *)AnyUnionArray3},
    
17.          (AnyUnionType){.Float = 2.4f}),
    
18.       };
    
19. //-------------------------------------------------------------
    
20.       AnyUnionType AnyUnionArray4[] = {
    
21.         ((AnyUnionType){.Int = 1},
    
22.          (AnyUnionType){.Float = 1.2f},
    
23.          (AnyUnionType){.Char = 'a'},
    
24.          (AnyUnionType){.pString = "Hello"},
    
25.          (AnyUnionType){.pIntArray = (int []){1, 2, 3, 4}},
    
26.          (AnyUnionType){.pFunction = SystemInit},
    
27.          (AnyUnionType){.pAnyUnion = (AnyUnionType []){(AnyUnionType){.Int = 2},
    
28.                                                        (AnyUnionType){.Float = 2.4f},
    
29.                                                        (AnyUnionType){.Char = 'b'},
    
30.                                                        (AnyUnionType){.pString = "World"},
    
31.                                                        (AnyUnionType){.pIntArray = (int []){5, 6, 7, 8}},
    
32.                                                        (AnyUnionType){.pFunction = SystemInit},
    
33.                                                        (AnyUnionType){.pAnyUnion = (AnyUnionType *)AnyUnionArray4}}}),
    
34.          
    
35.         ((AnyUnionType){.Int = 3},
    
36.          (AnyUnionType){.Float = 3.6f},
    
37.          (AnyUnionType){.Char = 'c'},
    
38.          (AnyUnionType){.pString = "Hello"},
    
39.          (AnyUnionType){.pIntArray = (int []){9, 10, 11, 12}},
    
40.          (AnyUnionType){.pFunction = SystemInit},
    
41.          (AnyUnionType){.pAnyUnion = (AnyUnionType []){(AnyUnionType){.Int = 4},
    
42.                                                        (AnyUnionType){.Float = 4.8f},
    
43.                                                        (AnyUnionType){.Char = 'd'},
    
44.                                                        (AnyUnionType){.pString = "World"},
    
45.                                                        (AnyUnionType){.pIntArray = (int []){13, 14, 15, 16}},
    
46.                                                        (AnyUnionType){.pFunction = SystemInit},
    
47.                                                        (AnyUnionType){.pAnyUnion = (AnyUnionType *)AnyUnionArray4}}}),
    
48.       };

复制代码

编译设置：

  
Union初始化：

  
Union成员赋值：

  
Union成员赋值：

laoshuhunya

技术宅 发表于 2018-12-26 15:54
首先这样很费RAM，第二这样很难理解，对后面维护的人来说可能比较吃力，第三也是最重要的，一大堆告警无法 ...

补张图片：

xhcyfc

收藏，好好看看

takashiki

laoshuhunya 发表于 2018-12-26 20:29
警告可以消除，对于有严重强迫症的嵌入式工程师，绝对是不能容忍任何警告的：

看您写的代码这么规整，看来平时一定是个认真的人，有代码洁癖，比我强多了。
不过不好意思，我估计您是没有理解我的意思还是忘了[]还是曲解了，您这个和我的完全不一样啊，全都少了一个维度。
比如您的AnyUnionVariable1，我的原意是MyAnyUnionVariable1，是数组而不是单个联合体，其中的每一项是数组的成员而不是联合体的成员：

但是遗憾的是，警告依然无法消除，不知道怎么搞。

thyewfty

我就是不注重警告的人，这种新写法学习了。

myrgb

基础太薄弱没看懂，哪位大神给个工程范例好好的理解下。谢谢

laoshuhunya

takashiki 发表于 2018-12-27 06:50
看您写的代码这么规整，看来平时一定是个认真的人，有代码洁癖，比我强多了。
不过不好意思，我估计您是 ...

过谦了，有空再好好研究下。
从语言角度讲，数组的维度应该不是问题，大部分警告是强制类型转换引起的。

tomzbj

albert_w 发表于 2018-11-30 10:55
要我想的话, 菜单文字统一放起来. 每个节点类型一样的结构体. 标记兄弟姐妹子节点, 搞个树 ...

只要记录一个父节点就行了，遍历所有菜单项把所有相同父节点的子项放在一起作为当前层级菜单项显示，反正菜单项一般不会很多

我的菜单程序，用了很久了：

1. #define MAX_NAME_LEN 24
   
2. #define MAX_MENU_ITEMS 64
   
3. #define ITEMS_PER_PAGE 4
   
4. #define TOPLEVEL 255
   
5. 
   
6. typedef struct {
   
7.     unsigned char parent;   // 上层菜单项, TOPLEVEL则为顶层菜单   
   
8.     bool isdir;             // 是否是目录, 是则进入下层菜单, 否则执行action操作  
   
9.     unsigned short val;      // 菜单项值     
   
10.     char *name;             // 菜单项名称      
    
11.     void (*action)(int param);  // 操作
    
12. } MenuItemTypeDef;
    
13. 
    
14. static struct {
    
15.     int item_count;
    
16.     int menu_group;
    
17.     int menu_pos;
    
18.     MenuItemTypeDef menu[MAX_MENU_ITEMS];
    
19. } g;
    
20. 
    
21. static int AddItem(int parent, bool isdir, unsigned char* name,  unsigned short val)
    
22. {
    
23.     int ret, namelen = 0;
    
24.     g.menu[g.item_count].parent = parent;
    
25.     g.menu[g.item_count].isdir = isdir;
    
26. 
    
27.     namelen = strlen((char*)name);
    
28.     if(namelen > MAX_NAME_LEN)
    
29.         namelen = MAX_NAME_LEN;
    
30.     g.menu[g.item_count].name = malloc(namelen + 2);
    
31.     if(g.menu[g.item_count].name == NULL)
    
32.         return -1;
    
33.     bzero(g.menu[g.item_count].name, namelen + 2);
    
34.     strncpy(g.menu[g.item_count].name, (char*)name, namelen);
    
35.     g.menu[g.item_count].val = val;
    
36.     ret = g.item_count;
    
37.     g.item_count++;
    
38. 
    
39.     return ret;
    
40. }

复制代码

使用时只要先建立几个顶级菜单项，

1. int top1 = AddItem(TOPLEVEL, true,  "1111111111111", 0);
   
2. int top2 = AddItem(TOPLEVEL, true,  "22222222222", 0);
   
3. int top3 = AddItem(TOPLEVEL, true,  "3333333333", 0);
   
4. 然后继续用顶级菜单项的id创建子菜单项就行了
   
5. AddItem(top1, false, "aaaaaa", 100);
   
6. AddItem(top1, false, "bbbbbb", 200);
   

复制代码

laoshuhunya

myrgb 发表于 2018-12-27 09:34
基础太薄弱没看懂，哪位大神给个工程范例好好的理解下。谢谢

复合字面量，就是生成并初始化一个指定类型的无名对象。个人认为重点要理解的还是类型、地址、指针、栈这些基本概念，这篇文章非常不错，可以看看：
深入理解C语言指针的奥秘



然后再看这个图：




最后，任何指针问题都可以在这张图里找到答案：

laoshuhunya

takashiki 发表于 2018-12-27 06:50
看您写的代码这么规整，看来平时一定是个认真的人，有代码洁癖，比我强多了。
不过不好意思，我估计您是 ...

这样可以消除警告：




编译输出：

Gorgon_Meducer

看到也有人用类似的方法，我就放心了。以后看来挨打的时候，我知道，不是只有我一个人挨打。

lihebb

takashiki 发表于 2018-12-26 16:11
第一，费RAM从何说起。
第二，不是更好理解吗，好多动态语言数据就是这么干的。
第三，把警告关了就好了 ...

有警告强迫症的接收不了

waymcu

收蔵学习！

visonlee

记号一下，现在还无法完全理解。

oooios

lihai le
无法完全理解

blxy

我的天那，感觉像是打开了新世界！