问题

在低级别的裸机嵌入式环境中，我想在内存中以C ++结构创建一个空白且没有任何名称的名称，以禁止用户访问此类内存位置。

现在，我通过放置一个丑陋的uint32_t :96;位域（可以方便地代替三个词）来实现它，但是它会引起GCC的警告（位域太大，无法容纳在uint32_t中），这是非常合理的。

虽然可以正常工作，但是当您要分发包含数百种警告的库时，它并不是很干净。

我该怎么做呢？

为什么首先存在问题？

我正在从事的项目包括定义整个微控制器系列（STMicroelectronics STM32）的不同外设的存储器结构。为此，结果是一个类，其中包含多个结构的联合，这些结构定义了所有寄存器，具体取决于目标微控制器。

下面是一个非常简单的外设的简单示例：通用输入/输出（GPIO）

union
{

    struct
    {
        GPIO_MAP0_MODER;
        GPIO_MAP0_OTYPER;
        GPIO_MAP0_OSPEEDR;
        GPIO_MAP0_PUPDR;
        GPIO_MAP0_IDR;
        GPIO_MAP0_ODR;
        GPIO_MAP0_BSRR;
        GPIO_MAP0_LCKR;
        GPIO_MAP0_AFR;
        GPIO_MAP0_BRR;
        GPIO_MAP0_ASCR;
    };
    struct
    {
        GPIO_MAP1_CRL;
        GPIO_MAP1_CRH;
        GPIO_MAP1_IDR;
        GPIO_MAP1_ODR;
        GPIO_MAP1_BSRR;
        GPIO_MAP1_BRR;
        GPIO_MAP1_LCKR;
        uint32_t :32;
        GPIO_MAP1_AFRL;
        GPIO_MAP1_AFRH;
        uint32_t :64;
    };
    struct
    {
        uint32_t :192;
        GPIO_MAP2_BSRRL;
        GPIO_MAP2_BSRRH;
        uint32_t :160;
    };
};

其中所有GPIO_MAPx_YYY都是宏，定义为uint32_t :32或寄存器类型（专用结构）。

在这里，您会看到uint32_t :192;效果很好，但是会触发警告。

到目前为止，我已经考虑了：

我可能已将其替换为数个uint32_t :32;（此处为6个），但在某些极端情况下，我有uint32_t :1344;42个（其中包括）。因此，即使结构生成已编写脚本，我也不愿在其他8k之上添加约一百行。

确切的警告消息是这样的：（ width of 'sool::ll::GPIO::<anonymous union>::<anonymous struct>::<anonymous>' exceeds its type我只是喜欢它的阴暗程度）。

我宁愿不通过简单地删除警告来解决此问题，而是使用

#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-WTheRightFlag"
/* My code */
#pragma GCC diagnostic pop

可能是一个解决方案...如果我找到TheRightFlag。但是，正如该线程中指出的那样，gcc/cp/class.c具有以下可悲的代码部分：

warning_at (DECL_SOURCE_LOCATION (field), 0,
        "width of %qD exceeds its type", field);

告诉我们没有-Wxxx标记可删除此警告...

使用多个相邻的匿名位域。所以代替：

    uint32_t :160;

例如，您将拥有：

    uint32_t :32;
    uint32_t :32;
    uint32_t :32;
    uint32_t :32;
    uint32_t :32;

每个要匿名的注册者一个。

如果要填充的空间很大，使用宏来重复单个32位空间可能会更清晰，更容易出错。例如，给定：

#define REPEAT_2(a) a a
#define REPEAT_4(a) REPEAT_2(a) REPEAT_2(a)
#define REPEAT_8(a) REPEAT_4(a) REPEAT_4(a)
#define REPEAT_16(a) REPEAT_8(a) REPEAT_8(a)
#define REPEAT_32(a) REPEAT_16(a) REPEAT_16(a)

然后可以添加1344（42 * 32位）空间，从而：

struct
{
    ...
    REPEAT_32(uint32_t :32;) 
    REPEAT_8(uint32_t :32;) 
    REPEAT_2(uint32_t :32;)
    ...
};

C ++风格的方式怎么样？

namespace GPIO {

static volatile uint32_t &MAP0_MODER = *reinterpret_cast<uint32_t*>(0x4000);
static volatile uint32_t &MAP0_OTYPER = *reinterpret_cast<uint32_t*>(0x4004);

}

int main() {
    GPIO::MAP0_MODER = 42;
}

由于GPIO名称空间，您将获得自动补全功能，并且不需要虚拟填充。甚至，更清楚的是发生了什么，因为您可以看到每个寄存器的地址，所以您完全不必依赖编译器的填充行为。

在嵌入式系统领域，您可以通过使用结构或定义指向寄存器地址的指针来对硬件建模。

不建议按结构建模，因为允许编译器在成员之间添加填充以达到对齐目的（尽管许多嵌入式系统的编译器都具有用于打包结构的编译指示）。

例：

uint16_t * const UART1 = (uint16_t *)(0x40000);
const unsigned int UART_STATUS_OFFSET = 1U;
const unsigned int UART_TRANSMIT_REGISTER = 2U;
uint16_t * const UART1_STATUS_REGISTER = (UART1 + UART_STATUS_OFFSET);
uint16_t * const UART1_TRANSMIT_REGISTER = (UART1 + UART_TRANSMIT_REGISTER);

您还可以使用数组符号：

uint16_t status = UART1[UART_STATUS_OFFSET];  

如果必须使用结构恕我直言，跳过地址的最佳方法是定义一个成员而不访问它：

struct UART1
{
  uint16_t status;
  uint16_t reserved1; // Transmit register
  uint16_t receive_register;
};

在我们的一个项目中，我们同时拥有来自不同供应商的常量和结构（供应商1使用常量，而供应商2使用结构）。

geza的权利是您确实不想为此使用类。

但是，如果要坚持的话，添加未使用的n字节宽度的成员的最佳方法就是这样做：

char unused[n];

如果添加特定于实现的杂注以防止在类的成员中添加任意填充，则此方法可以起作用。

对于GNU C / C ++（gcc，clang和其他支持相同扩展名的其他语言），放置属性的有效位置之一是：

#include <stddef.h>
#include <stdint.h>
#include <assert.h>  // for C11 static_assert, so this is valid C as well as C++

struct __attribute__((packed)) GPIO {
    volatile uint32_t a;
    char unused[3];
    volatile uint32_t b;
};

static_assert(offsetof(struct GPIO, b) == 7, "wrong GPIO struct layout");

（Godbolt编译器资源管理器上的示例显示offsetof(GPIO, b)= 7个字节。）

扩展@Clifford和@Adam Kotwasinski的答案：

#define REP10(a)        a a a a a a a a a a
#define REP1034(a)      REP10(REP10(REP10(a))) REP10(a a a) a a a a

struct foo {
        int before;
        REP1034(unsigned int :32;)
        int after;
};
int main(void){
        struct foo bar;
        return 0;
}

要扩展Clifford的答案，您始终可以宏出匿名位域。

所以代替

uint32_t :160;

用

#define EMPTY_32_1 \
 uint32_t :32
#define EMPTY_32_2 \
 uint32_t :32;     \ // I guess this also can be replaced with uint64_t :64
 uint32_t :32
#define EMPTY_32_3 \
 uint32_t :32;     \
 uint32_t :32;     \
 uint32_t :32
#define EMPTY_UINT32(N) EMPTY_32_ ## N

然后像

struct A {
  EMPTY_UINT32(3);
  /* which resolves to EMPTY_32_3, which then resolves to real declarations */
}

不幸的是，您将需要与EMPTY_32_X字节一样多的变体:(尽管如此，它允许您在结构中具有单个声明。

将大间隔符定义为32位的组。

#define M_32(x)   M_2(M_16(x))
#define M_16(x)   M_2(M_8(x))
#define M_8(x)    M_2(M_4(x))
#define M_4(x)    M_2(M_2(x))
#define M_2(x)    x x

#define SPACER int : 32;

struct {
    M_32(SPACER) M_8(SPACER) M_4(SPACER)
};

我认为引入更多的结构将是有益的。进而可以解决隔离物的问题。

命名变体

虽然平面名称空间不错，但问题是您最终会杂乱地收集字段，而没有简单的方法将所有相关字段一起传递。此外，通过在匿名联合中使用匿名结构，您不能传递对结构本身的引用，也不能将其用作模板参数。

因此，作为第一步，我将考虑突破struct：

// GpioMap0.h
#pragma once

// #includes

namespace Gpio {
struct Map0 {
    GPIO_MAP0_MODER;
    GPIO_MAP0_OTYPER;
    GPIO_MAP0_OSPEEDR;
    GPIO_MAP0_PUPDR;
    GPIO_MAP0_IDR;
    GPIO_MAP0_ODR;
    GPIO_MAP0_BSRR;
    GPIO_MAP0_LCKR;
    GPIO_MAP0_AFR;
    GPIO_MAP0_BRR;
    GPIO_MAP0_ASCR;
};
} // namespace Gpio

// GpioMap1.h
#pragma once

// #includes

namespace Gpio {
struct Map1 {
    // fields
};
} // namespace Gpio

// ... others headers ...

最后，全局头：

// Gpio.h
#pragma once

#include "GpioMap0.h"
#include "GpioMap1.h"
// ... other headers ...

namespace Gpio {
union Gpio {
    Map0 map0;
    Map1 map1;
    // ... others ...
};
} // namespace Gpio

现在，我可以编写void special_map0(Gpio:: Map0 volatile& map);，并快速了解所有可用架构。

简单的垫片

将定义拆分为多个标头后，标头就可以单独进行管理。

因此，我最初要完全满足您的要求的方法是坚持重复std::uint32_t:32;。是的，它在现有的8k行中增加了几百条线，但是由于每个标头分别较小，因此可能不会那么糟。

但是，如果您愿意考虑更多奇特的解决方案...

介绍$。

鲜为人知的事实$是C ++标识符的可行性。它甚至是一个可行的起始字符（与数字不同）。

一个$在源代码中出现可能会引人侧目，并$$$$肯定会在代码审查，以引起人们的注意。您可以轻松利用以下优势：

#define GPIO_RESERVED(Index_, N_) std::uint32_t $$$$##Index_[N_];

struct Map3 {
    GPIO_RESERVED(0, 6);
    GPIO_MAP2_BSRRL;
    GPIO_MAP2_BSRRH;
    GPIO_RESERVED(1, 5);
};

您甚至可以将一个简单的“棉绒”放在一起作为预提交的钩子，或者放在您的CI中，以$$$$在已提交的C ++代码中查找并拒绝此类提交。

尽管我同意不应将结构用于MCU I / O端口访问，但可以通过以下方式回答原始问题：

struct __attribute__((packed)) test {
       char member1;
       char member2;
       volatile struct __attribute__((packed))
       {
       private:
              volatile char spacer_bytes[7];
       }  spacer;
       char member3;
       char member4;
};

根据您的编译器语法，您可能需要替换__attribute__((packed))为#pragma pack或类似。

在结构中混合私有成员和公共成员通常会导致C ++标准不再保证内存布局。但是，如果结构的所有非静态成员都是私有的，则仍将其视为POD /标准布局，嵌入它们的结构也将被视为POD /标准布局。

由于某种原因，如果匿名结构的成员是私有的，则gcc会产生警告，因此我必须给它起一个名字。或者，将其包装到另一个匿名结构中也可以摆脱警告（这可能是一个错误）。

请注意，spacer成员本身不是私有的，因此仍可以通过以下方式访问数据：

(char*)(void*)&testobj.spacer;

但是，这样的表达看起来很明显，希望在没有充分理由的情况下不能使用，更不用说是错误了。

反解。

不要这样做：混合私有和公共领域。

带有计数器以生成uniqie变量名称的宏也许有用吗？

#define CONCAT_IMPL( x, y ) x##y
#define MACRO_CONCAT( x, y ) CONCAT_IMPL( x, y )
#define RESERVED MACRO_CONCAT(Reserved_var, __COUNTER__) 


struct {
    GPIO_MAP1_CRL;
    GPIO_MAP1_CRH;
    GPIO_MAP1_IDR;
    GPIO_MAP1_ODR;
    GPIO_MAP1_BSRR;
    GPIO_MAP1_BRR;
    GPIO_MAP1_LCKR;
private:
    char RESERVED[4];
public:
    GPIO_MAP1_AFRL;
    GPIO_MAP1_AFRH;
private:
    char RESERVED[8];
};