PROSAGA码农传奇-C/C++-是否可以在堆栈上分配结构，并将其定义隐藏在源文件中？

0# Minions | 2019-08-31 10-32

1# 荀彧. | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  
    某些实现保证编译单元之间的调用将以与平台的应用程序二进制接口（ABI）一致的方式处理，而不考虑被调用函数将对其接收的地址或调用者将执行的操作执行的操作。存储其提供的地址，或者一旦函数返回就会执行此类存储。在这样的实现上，给出如下内容：
  
   <pre>
 <code>
 // In header
typedef union FOO_PUBLIC_UNION { 
 uint64_t dat[4]; // Allocate space
 double dummy_align1; // Force alignment
 void *dummy_align2; // Force alignment
} FOO;
void act_on_foo(FOO_PUBLIC_UNION*);

// In code
FOO x = {0};
act_on_foo(&x);

</code>
 </pre>
  
    在一个编译单元中，类似于：
  
   <pre>
 <code>
 struct FOO_PRIVATE {
 int this; float that; double whatever;
};

typedef union FOO_PUBLIC_UNION { uint64_t dat[4]; struct FOO_PRIVATE priv; } FOOPP;

void act_on_foo(FOO *p)
{
  FOOPP *pp = (FOOPP*)p;
  pp->priv.whatever = 1234.567;
}

</code>
 </pre>
  
    只要大小
     <code>
 FOO
 </code>
     和
     <code>
 FOOPP
 </code>
     匹配，从第一个编译单元调用外部函数的行为将被定义为分配
     <code>
 sizeof(FOO)
 </code>
     字节，将它们归零，并将它们的地址传递给
     <code>
 act_on_foo
 </code>
    ，然后将其行为定义为对其接收地址的字节进行操作，而不考虑它们如何获取其值或稍后调用者将如何处理它们。
  
  
    不幸的是，即使几乎每个实现都应该能够产生与调用它一无所知的函数一致的行为，但是没有标准的方法向编译器指示特定的函数调用应该被视为“不透明”。旨在用于有用目的的实现可以并且通常使用“普通”函数调用来支持这样的语义，无论标准是否需要，并且这样的语义对于仅用于它们不会有用的目的的实现几乎没有价值。 。不幸的是，这导致了一个Catch 22：没有理由要求标准强制要求实现在有或没有授权的情况下可以自由执行，如果它们有用，但是一些编译器编写者认为标准缺乏任务是鼓励拒绝支持。
  
</DIV>

2# 诸葛神侯 | 2019-08-31 10-32

<div class =“post-text”itemprop =“text”>
  
    您
    
      能够
    
     使用VLA或
    <a href="http://man7.org/linux/man-pages/man3/alloca.3.html" rel="nofollow noreferrer">
       <code>
 alloca
 </code>
    </A>
     在Linux中：
  
  
    图书馆标题：
  
   <pre>
 <code>
 struct StackList_s;
typedef struct StackList_s StackList_t;
extern const size_t StackList_size;

// If you're using VLAs
extern const size_t StackList_align;
StackList_t* stl_init_inline(char stack_source[], ...);

</code>
 </pre>
  
    图书馆来源：
  
   <pre>
 <code>
 #include "header.h"

struct StackList_s {
    // ...
};

const size_t StackList_size = sizeof(StackList_t);

// If you're using VLAs
#include <stdalign.h>
#include <stdint.h>

const size_t StackList_align = alignof(StackList_t);
StackList_t* stl_init_inline(char stack_source[], ...) {
    // align the address to the nearest multiple of StackList_align
    uintptr_t address = (uintptr_t) ((void*) stack_source);
    if (address % StackList_align != 0) {
        address += StackList_align - address % StackList_align;
    }
    StackList_t* stack = (StackList_t*) ((void*) address);
    stl_init(stack, ...);
    return stack;
}

</code>
 </pre>
  
    主要来源
  
   <pre>
 <code>
 #include <header.h>

StackList_t* stack = alloca(Stacklist_size);
stl_init(stack, ...);

char stack_source[StackList_size + StackList_align - 1];  // Not compile time.
StackList_t* stack = stl_init_inline(stack_source, ...);

</code>
 </pre>
  
    这个
    
      将
    
     将它分配到堆栈上，你不需要释放它，但它比它更慢，更冗长
     <code>
 StackList_t stack_source;
 </code>
    。 （和
     <code>
 alloca
 </code>
     仅限Linux）
  
  
    对于第二个问题，您需要一个结构的完整定义来获得它的大小。常见的陷阱包括这样的事实
     <code>
 sizeof(struct { int a; }) == sizeof(struct { int a; })
 </code>
     可能是假的。它可能不会，所以你可以这样做
     <code>
 #define StackList_size sizeof(struct { integer_t count; struct StackListNode_s *top; integer_t version_id; })
 </code>
     但这也导致了大量的代码重复。
  
  
    我个人只是将结构定义放在头文件中，只是在某处的注释中声明“不要弄乱成员或我的方法不起作用”（也许让名字开始于
     <code>
 _
 </code>
     暗示他们是私人的）
  
</DIV>