列出 const 和数组结构字段的初始化

Question

最近刚开始为微控制器进行 C++ 编程，我遇到了一些情况*，在结构上使用非静态 const 字段会很方便，该结构始终保证具有固定值（对于每个sturct 的实例，永远）。

给定一个结构

struct S {
    const uint8_t c; // Should always be 42
    char v;
    uint32_t arr[4];
}

我希望c 成为一个常量值，并且每次都使用相同的常量值。我希望能够使用大括号初始化列表的便利性来设置 v 和 arr 的成员，如

S some_var = {'v', { 0, 1, 2, 3 } };

因为我希望c 是一个常量，所以我的印象是我必须使用初始化列表来设置c，例如S() : c(42) {}，它工作得很好，只要我不尝试也初始化arr，在这种情况下，我不知道列表应该是什么样子。这使用 C++11 可行吗？ （如果这在 C++11 中不可行，但在一些较新的标准中，也对答案感兴趣。）

示例代码：

#include <stdio.h>
#include <stdint.h>

struct S {
    const uint8_t c; // Should always be 42 on every instance
                     // of the struct due to hardware shenanigance
                     // (i.e. this struct is the representation of a register value)
    char v;
    uint32_t arr[4];

    // This allows using "S s1;"
    S() : c(42), v('a'), arr{} {}

    // This allows using "S s2 = { 'v', 0, 1, 2, 3 };" works but it's clumsy:
    S(uint32_t v, uint32_t arr0, uint32_t arr1, uint32_t arr2, uint32_t arr3) :
        c(42), v(v), arr{ arr0, arr1, arr2, arr3 } {}

    // I would like to do something along the lines of "S s2 = { 'v', { 0, 1, 2, 3 } };":
    // S(uint32_t v, uint32_t arr[4] /*?*/) :
    //     c(42), v(v), arr{/*?*/} {}

};

// Main just for the sake of completeness
int main() {
    // Works just fine
    S s1;
    printf("s1.c = %u\n", s1.c); // 42
    printf("s1.v = '%c'\n", s1.v); // a
    printf("s1.arr[3] = %u\n", s1.arr[3]); // 0

    // Initialiation like this works with the line:12 signature:
    S s2 = { 'v', 0, 1, 2, 3 };

    // I'd like to initialize like this:
    // S s2 = { 'v', { 0, 1, 2, 3 } };

    printf("s2.c = %u\n", s2.c); // 42
    printf("s2.v = '%c'\n", s2.v); // v
    printf("s2.arr[3] = %u\n", s2.arr[3]); // 3
    return 0;
}

---

*关于我为什么要这样做的上下文：这似乎是一件奇怪的事情，因为如果值始终相同，为什么还要麻烦存储它呢？想象一下，所讨论的结构是一个位域，它对应于与微控制器通信的 IC 的寄存器。这些寄存器有时具有“保留”字段，数据表指定您必须在这些字段中写入的值。从程序员的角度来看，如果我不必手动设置这些位，那会很方便。

Answer 1

C++11 为您提供std::array，它就像一个原始数组，但没有任何“负数”（数组衰减，无法复制）。使用它你可以得到你想要的东西

struct S {
    const uint8_t c = 42;
    char v = 'a';
    std::array<uint32_t, 4> arr{};

    // This allows using "S s1;"
    S() {}

    S(uint32_t v, std::array<uint32_t, 4> arr) : v(v), arr{arr} {}
};

// Main just for the sake of completeness
int main() {
    // Works just fine
    S s1;
    printf("s1.c = %u\n", s1.c); // 42
    printf("s1.v = '%c'\n", s1.v); // a
    printf("s1.arr[3] = %u\n", s1.arr[3]); // 0

    S s2 = { 'v', { 0, 1, 2, 3 } };

    printf("s2.c = %u\n", s2.c); // 42
    printf("s2.v = '%c'\n", s2.v); // v
    printf("s2.arr[3] = %u\n", s2.arr[3]); // 3
    return 0;
}

哪个输出

s1.c = 42
s1.v = 'a'
s1.arr[3] = 0
s2.c = 42
s2.v = 'v'
s2.arr[3] = 3

---

如果您绝对必须在S 中有一个原始数组，那么您的另一个选择是在构造函数中使用std::initializer_list。看起来像

struct S {
    const uint8_t c = 42;
    char v = 'a';
    uint32_t arr[4]{};

    // This allows using "S s1;"
    S() {}

    S(uint32_t v, std::initializer_list<uint32_t> data) : v(v)
    {
        int i = 0;
        for (auto e : data)
            arr[i++] = e;
    }
};

// Main just for the sake of completeness
int main() {
    // Works just fine
    S s1;
    printf("s1.c = %u\n", s1.c); // 42
    printf("s1.v = '%c'\n", s1.v); // a
    printf("s1.arr[3] = %u\n", s1.arr[3]); // 0

    S s2 = { 'v', { 0, 1, 2, 3 } };

    printf("s2.c = %u\n", s2.c); // 42
    printf("s2.v = '%c'\n", s2.v); // v
    printf("s2.arr[3] = %u\n", s2.arr[3]); // 3
    return 0;
}

您得到的结果与使用 std::array 的代码相同。