blocks|key|93564|text|#include+<stdio.h>
#include+<stdint.h>

typedef+struct+Object
{
++uint8_t+size;
++uint8_t+array[5];
}+Object;

int+main()+{
++++Object+o+=+{+.size+=+2,++{1,+2}};
++++printf("%25d+%25d\n",+o.array[0],+o.array[1]);
}|type|code-block|depth|inlineStyleRanges|entityRanges|data|syntax|javascript|93565|这是用cc+-std=c99在macOS上用clang14.0.0编译的。它的产出如下：|unstyled|offset|length|style|CODE|93566|1+2|93567|entityMap^0|0|3|B|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@]|9|@]|A|$B|C]]|$1|D|3|E|5|F|7|P|8|@$G|Q|H|R|I|J]]|9|@]|A|$]]|$1|K|3|L|5|6|7|S|8|@]|9|@]|A|$B|C]]|$1|M|3|-4|5|F|7|T|8|@]|9|@]|A|$]]]|N|$]]

<pre><code>#include &lt;stdio.h&gt;
#include &lt;stdint.h&gt;

typedef struct Object
{
 uint8_t size;
 uint8_t array[5];
} Object;

int main() {
 Object o = { .size = 2, {1, 2}};
 printf(&quot;%d %d\n&quot;, o.array[0], o.array[1]);
}
</code></pre>
This compiles for me with <code>cc -std=c99</code> in clang 14.0.0 on macOS. It outputs:
<pre><code>1 2
</code></pre>

blocks|key|1016674|text|像这样分配数组大小的正常方法是使用宏，这样您就可以轻松地更改它并在代码的其他地方使用它的大小。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1016675|#define+MYARRAYSIZE+10

typedef+struct+
{
++uint8_t+size;
++uint8_t+array[MYARRAYSIZE];
}Object_t;|code-block|syntax|javascript|1016676|另一种方法是使其成为指针，然后在运行时使用malloc动态分配内存。可以这样声明大得多的数组。|1016677|#define+MYARRAYSIZE+10

typedef+struct+
{
++uint8_t+size;
++uint8_t+*array;
}Object_t;
+...
Object_t+Object;
Object.array+=+(uint8_t+*)malloc(MYARRAYSIZE*sizeof(uint8_t));|1016678|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|D|7|P|8|@]|9|@]|A|$E|F]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

The normal way to allocate the size of an array like this so you can easily change it and use the size of it elsewhere in the code is to use a macro.
<pre><code>#define MYARRAYSIZE 10

typedef struct 
{
 uint8_t size;
 uint8_t array[MYARRAYSIZE];
}Object_t;
</code></pre>
The other way to do is to make it a pointer and then allocate the memory dynamically at runtime with malloc. Much bigger arrays can be declared this way.
<pre><code>#define MYARRAYSIZE 10

typedef struct 
{
 uint8_t size;
 uint8_t *array;
}Object_t;
 ...
Object_t Object;
Object.array = (uint8_t *)malloc(MYARRAYSIZE*sizeof(uint8_t));
</code></pre>

blocks|key|1011189|text|如果使用方言扩展语言的语义，充分放宽“严格的混叠规则”，以坚持C精神原则“不要阻止程序员做需要做的事情”，一种常见的方法是这样做：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1011190|struct+polygon+{+int+sides;+int+coords[];+};

struct+poly5+{+int+sides;+int+coords[10];+}
++const+myPentagonn+=+{5,+{0,-5,+4,-3,+3,5,+-3,5,+-4,-3}+};

#define+myPentagon+(*((struct+polygon*)&myPentagonn))|code-block|syntax|javascript|1011191|在预先标准的方言中，通常需要声明多边形包含一个零元素数组，或者如果编译器决定是一个烦人的单元素数组，但是对于函数是否应该能够对多个类似的结构类型进行交互操作(如这里的例子)，这一点从来没有任何疑问。这样的结构，经过一些调整，在1974年的C方言中得到了承认，适合于低级编程的方言将支持它们，而不考虑标准是否会要求这样的支持。|1011192|一些不接受标准作者的意图的clang/gcc粉丝将坚持认为，任何需要使用-fno严格混叠的代码都会被打破。然而，该标准的意图是将对此类结构的支持视为标准管辖范围之外的实施质量问题。一个为永远不需要也不会受益于任何低级别内存操作的任务而设计的实现可能比满足这些需求的任务更有效，但这并不意味着打算在低级别处理内存的代码应该跳过圈来与这些专门的实现或配置兼容。|1011193|entityMap^0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|M|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|N|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|O|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|P|8|@]|9|@]|A|$]]|$1|K|3|-4|5|6|7|Q|8|@]|9|@]|A|$]]]|L|$]]

If one uses dialects that extend the semantics of the language by relaxing the &quot;strict aliasing rule&quot; sufficiently to uphold the Spirit of C principle &quot;Don't prevent the programmer from doing what needs to be done&quot;, a common approach is to do something like:
<pre><code>struct polygon { int sides; int coords[]; };

struct poly5 { int sides; int coords[10]; }
 const myPentagonn = {5, {0,-5, 4,-3, 3,5, -3,5, -4,-3} };

#define myPentagon (*((struct polygon*)&amp;myPentagonn))
</code></pre>
In pre-standard dialects, it would often have been necessary to either declare polygon as containing a zero-element array, or if compilers decided to be annoying, a single-element array, but there was never any doubt about whether functions should be able to act upon multiple similar structure types interchangeably as exemplified here. Such constructs, with a few adjustments, were recognized in the 1974 dialect of C, and dialects suitable for low-level programming will support them without regard for whether or not the Standard would mandate such support.
Some clang/gcc fans who don't accept the intentions of the authors of the Standard as expressed in the published Rationale documents will insist that any code which would require the use of -fno-strict-aliasing is broken. The intention of the Standard, however, was to treat support for such constructs as a quality-of-implementation issue outside the Standard's jurisdiction. An implementation which is intended for tasks that would never need nor benefit from any kind of low-level memory manipulation might be more efficient for such tasks than would be one that accommodates such needs, but that doesn't mean code that is intended to work with memory at a low level should jump through hoops to be compatible with such specialized implementations or configurations.

blocks|key|1011202|text|我建议您为所需的每个大小的Object定义一个类型。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|1011203|您可以通过定义一些宏来简化它：|1011204|#include+<stdint.h>
#include+<stdlib.h>

#define+OBJINIT(x)+(Object##x){.size+=+x+}
#define+DEFOBJ(x)+++++\
typedef+struct++++++++\
{+++++++++++++++++++++\
++uint8_t+size;+++++++\
++uint8_t+array[x];+++\
}+Object##x;++++++++++\
Object##x+*CreateObject##x()+{++++++++++\
++++Object##x+*rv+=+malloc(sizeof+*rv);+\
++++if(!rv)+exit(1);++++++++++++++++++++\
++++*rv+=+OBJINIT(x);+++++++++++++++++++\
++++return+rv;++++++++++++++++++++++++++\
}

//+Define+the+types+with+the+sizes+you+need:
DEFOBJ(2)
DEFOBJ(5)

int+main(void)+{
++++Object2+o2+=+OBJINIT(2);+++++++++//+an+initialized+automatic+variable
++++
++++Object5*+o5p+=+CreateObject5();++//+an+initialized+dynamically+allocated+variable
++++free(o5p);
}|code-block|syntax|javascript|1011205|entityMap^0|D|6|0|0|0^^$0|@$1|2|3|4|5|6|7|O|8|@$9|P|A|Q|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|R|8|@]|D|@]|E|$]]|$1|H|3|I|5|J|7|S|8|@]|D|@]|E|$K|L]]|$1|M|3|-4|5|6|7|T|8|@]|D|@]|E|$]]]|N|$]]

I suggest that you define a type for each size of <code>Object</code> that you want.
You could simplify it by defining some macros:
<pre class="lang-c prettyprint-override"><code>#include &lt;stdint.h&gt;
#include &lt;stdlib.h&gt;

#define OBJINIT(x) (Object##x){.size = x }
#define DEFOBJ(x) \
typedef struct \
{ \
 uint8_t size; \
 uint8_t array[x]; \
} Object##x; \
Object##x *CreateObject##x() { \
 Object##x *rv = malloc(sizeof *rv); \
 if(!rv) exit(1); \
 *rv = OBJINIT(x); \
 return rv; \
}

// Define the types with the sizes you need:
DEFOBJ(2)
DEFOBJ(5)

int main(void) {
 Object2 o2 = OBJINIT(2); // an initialized automatic variable
 
 Object5* o5p = CreateObject5(); // an initialized dynamically allocated variable
 free(o5p);
}
</code></pre>

blocks|key|93167|text|您可以使用在复合文字中定义的联合：|type|unstyled|depth|inlineStyleRanges|entityRanges|data|93168|Object+*o+=+&(union+{+Object+o;
++++++++++++++++++++++//+anonymous+struct
++++++++++++++++++++++struct+{+uint8_t+size;+uint8_t+array[N];+};
++++++++++++++++++++}+)+{+.size+=+N+}.o;|code-block|syntax|javascript|93169|它可以很好地打包成一个宏。|93170|它在脚踏式模式下不加警告地编译，为全局和堆栈分配的对象产生预期的结果。请参阅https://godbolt.org/z/jhsbMseY8|offset|length|93171|这个解决方案是可以工作的，因为在C中，联盟的两个结构成员可以别名，只要他们共享共同的初始子序列。|93172|entityMap|0|LINK|mutability|MUTABLE|url|https://godbolt.org/z/jhsbMseY8^0|0|0|0|12|V|0|0|0^^$0|@$1|2|3|4|5|6|7|W|8|@]|9|@]|A|$]]|$1|B|3|C|5|D|7|X|8|@]|9|@]|A|$E|F]]|$1|G|3|H|5|6|7|Y|8|@]|9|@]|A|$]]|$1|I|3|J|5|6|7|Z|8|@]|9|@$K|10|L|11|1|12]]|A|$]]|$1|M|3|N|5|6|7|13|8|@]|9|@]|A|$]]|$1|O|3|-4|5|6|7|14|8|@]|9|@]|A|$]]]|P|$Q|$5|R|S|T|A|$U|V]]]]

You can use a union defined within a compound literal:
<pre><code>Object *o = &amp;(union { Object o;
 // anonymous struct
 struct { uint8_t size; uint8_t array[N]; };
 } ) { .size = N }.o;
</code></pre>
It can be quite well packed into a macro.
It compiles without a warning in pedantic mode producing the expected results for both global and stack-allocated object. See <a href="https://godbolt.org/z/jhsbMseY8" rel="nofollow noreferrer">https://godbolt.org/z/jhsbMseY8</a>
This solution is guaranteed to work because in C the two struct members of the union can alias as long as they share common initial subsequence.

blocks|key|1016776|text|首先，每当你发现自己有这种异国情调的需求时，请退后一步，看看你是否不能简化程序。使用晦涩的宏黑客始终是最后的手段，即使是在维护旧代码时也是如此。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|1016777|尽管如此，最不晦涩的解决方案可能是根据变量名称创建每个对象的唯一ty对联。然后在相同的宏中声明该类型的变量。那么它就可以在任何地方使用。|1016778|一个可能的解决办法是：|1016779|#define+create_obj(name,+...)++++++++++++++++++++++++\
typedef+struct+++++++++++++++++++++++++++++++++++++++\
{++++++++++++++++++++++++++++++++++++++++++++++++++++\
++uint8_t+size;++++++++++++++++++++++++++++++++++++++\
++uint8_t+array[sizeof(+(uint8_t[]){__VA_ARGS__}+)];+\
}+obj_##name;++++++++++++++++++++++++++++++++++++++++\
+++++++++++++++++++++++++++++++++++++++++++++++++++++\
obj_##name+name+=++++++++++++++++++++++++++++++++++++\
{++++++++++++++++++++++++++++++++++++++++++++++++++++\
++.size+=+sizeof(+(uint8_t[]){__VA_ARGS__}+),++++++++\
++.array+=+{+__VA_ARGS__+}+++++++++++++++++++++++++++\
}|code-block|syntax|javascript|1016780|将创建一个具有附加变量名的类型。它将不使用灵活的数组成员，而是使用固定大小的数组。它将不需要动态分配，它将不需要依赖异国情调的角落案例规则或非标准扩展。|1016781|如果使用的是uint8_t以外的另一个成员类型，那么只需使用通常的技巧来确定数组大小：|offset|length|style|CODE|1016782|sizeof((type[]){+__VA_ARGS__+})+/+sizeof(type[0])|1016783|1016784|示例：|1016785|#include+<stdint.h>
#include+<stdio.h>
#include+<inttypes.h>

#define+create_obj(name,+...)++++++++++++++++++++++++\
typedef+struct+++++++++++++++++++++++++++++++++++++++\
{++++++++++++++++++++++++++++++++++++++++++++++++++++\
++uint8_t+size;++++++++++++++++++++++++++++++++++++++\
++uint8_t+array[sizeof(+(uint8_t[]){__VA_ARGS__}+)];+\
}+obj_##name;++++++++++++++++++++++++++++++++++++++++\
+++++++++++++++++++++++++++++++++++++++++++++++++++++\
obj_##name+name+=++++++++++++++++++++++++++++++++++++\
{++++++++++++++++++++++++++++++++++++++++++++++++++++\
++.size+=+sizeof(+(uint8_t[]){__VA_ARGS__}+),++++++++\
++.array+=+{+__VA_ARGS__+}+++++++++++++++++++++++++++\
}


create_obj(filescope_obj,1,2,3);

int+main+(void)+
{
++create_obj(local_obj,1,2,3,4,5);

++for(size_t+i=0;+i<filescope_obj.size;+i%2B%2B)
++{
++++printf("%25"PRIu8+"+",+filescope_obj.array[i]);
++}
++puts("");
++for(size_t+i=0;+i<local_obj.size;+i%2B%2B)
++{
++++printf("%25"PRIu8+"+",+local_obj.array[i]);
++}
}|1016786|输出：|1016787|1+2+3+
1+2+3+4+5+|1016788|entityMap^0|0|0|0|0|0|6|7|0|0|1D|0|0|0|0|0|0^^$0|@$1|2|3|4|5|6|7|15|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|16|8|@]|9|@]|A|$]]|$1|D|3|E|5|6|7|17|8|@]|9|@]|A|$]]|$1|F|3|G|5|H|7|18|8|@]|9|@]|A|$I|J]]|$1|K|3|L|5|6|7|19|8|@]|9|@]|A|$]]|$1|M|3|N|5|6|7|1A|8|@$O|1B|P|1C|Q|R]]|9|@]|A|$]]|$1|S|3|T|5|6|7|1D|8|@$O|1E|P|1F|Q|R]]|9|@]|A|$]]|$1|U|3|-4|5|6|7|1G|8|@]|9|@]|A|$]]|$1|V|3|W|5|6|7|1H|8|@]|9|@]|A|$]]|$1|X|3|Y|5|H|7|1I|8|@]|9|@]|A|$I|J]]|$1|Z|3|10|5|6|7|1J|8|@]|9|@]|A|$]]|$1|11|3|12|5|H|7|1K|8|@]|9|@]|A|$I|J]]|$1|13|3|-4|5|6|7|1L|8|@]|9|@]|A|$]]]|14|$]]

First of all, whenever you find yourself with exotic requirements like this, please take a step back and see if you can't simplify the program instead. Using obscure macro hacks is always the last resort - and even then mostly just when maintaining old code.
That being said, the least obscure solution might be to create an unique typedef per object, based on variable name. And then declare a variable of that type in the same macro. Then it would be possible to use it anywhere.
One possible solution:
<pre><code>#define create_obj(name, ...) \
typedef struct \
{ \
 uint8_t size; \
 uint8_t array[sizeof( (uint8_t[]){__VA_ARGS__} )]; \
} obj_##name; \
 \
obj_##name name = \
{ \
 .size = sizeof( (uint8_t[]){__VA_ARGS__} ), \
 .array = { __VA_ARGS__ } \
}
</code></pre>
A type with the variable name appended will be created. It will not use a flexible array member but a fixed size array. It will not need dynamic allocation, it will not need to rely on exotic corner-case rules or non-standard extensions.
If another member type than <code>uint8_t</code> would be used, then simply determine the array size with the usual trick:
<code>sizeof((type[]){ __VA_ARGS__ }) / sizeof(type[0])</code>
<hr />
Example:
<pre><code>#include &lt;stdint.h&gt;
#include &lt;stdio.h&gt;
#include &lt;inttypes.h&gt;

#define create_obj(name, ...) \
typedef struct \
{ \
 uint8_t size; \
 uint8_t array[sizeof( (uint8_t[]){__VA_ARGS__} )]; \
} obj_##name; \
 \
obj_##name name = \
{ \
 .size = sizeof( (uint8_t[]){__VA_ARGS__} ), \
 .array = { __VA_ARGS__ } \
}


create_obj(filescope_obj,1,2,3);

int main (void) 
{
 create_obj(local_obj,1,2,3,4,5);

 for(size_t i=0; i&lt;filescope_obj.size; i++)
 {
 printf(&quot;%&quot;PRIu8 &quot; &quot;, filescope_obj.array[i]);
 }
 puts(&quot;&quot;);
 for(size_t i=0; i&lt;local_obj.size; i++)
 {
 printf(&quot;%&quot;PRIu8 &quot; &quot;, local_obj.array[i]);
 }
}
</code></pre>
Output:
<pre><code>1 2 3 
1 2 3 4 5 
</code></pre>

Consider the following code:
<pre><code>typedef struct Object
{
 uint8_t size;
 uint8_t array[];
}Object;
</code></pre>
How would I make the Object with a compile time but user defined size array?
After reading some stackoverflow posts and trying the code myself I now know that as long as I use at least the compiler standard C99 I can declare the Object with a custom size like this:
<pre><code>Object o = {.size = 2, .array = {1, 2}};
</code></pre>
But what I want is just an empty array with a custom size so instead of typing
<pre><code>Object o = {.size = 5, .array = {1, 2, 3, 4, 5}};
</code></pre>
i want to type something like
<pre><code>Object o = {.size = 5, .array = uint8_t[5]};
</code></pre>
What is also important is, that I need to know the array size at compile time and can't use dynamic memory like malloc so the typical solution of a flexible array member which is just allocated with the use of malloc wouldn't work for me.
Does a solution like this exist?
If it does not exist:
Why would the first example work (for some compilers) but just telling the compiler I need a size 10 array in the struct at compile time without initializing the values in it would not?
Edit:
I guess I should have made clear that my goal was to create something similar to the C++ <code>std::array</code> since with that datatype the user can just choose the size of the array without having to know the inner workings and rewriting the struct for every new size.

C: Initialize custom array size in struct at compile time

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

考虑以下代码：typedef struct Object{  uint8_t size;  uint8_t array[];}Object;如何使对象具有编译时但用户定义的大小数组？在阅读了一些堆栈溢出帖子并亲自尝试了代码之后，我现在知道，只要我至少使用编译器标准的C99，我就可以声明具有如下自定义大小的对象：Obje...

问C:在编译时在struct中初始化自定义数组大小
EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C:在编译时在struct中初始化自定义数组大小EN

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问C:在编译时在struct中初始化自定义数组大小
EN