C++11：将结构数组重新解释为结构成员数组

Question

考虑以下类型：

struct S
{
    char v;
};

给定一个const S 的数组，是否有可能以标准一致的方式，将其重新解释为const char 的数组，其元素对应于成员v 的值对于每个原始数组的元素，反之亦然？例如：

const S a1[] = { {'a'}, {'4'}, {'2'}, {'\0'} };
const char* a2 = reinterpret_cast< const char* >(a1);

for (int i = 0; i < 4; ++i)
    std::cout << std::boolalpha << (a1[i].v == a2[i]) << ' ';

上面的代码是可移植的，它会打印true true true true吗？如果没有，还有其他方法可以实现吗？

显然，可以创建一个新数组并使用原始数组的每个元素的成员v 对其进行初始化，但整个想法是避免创建一个新数组。

Answer 1

简单地说，不 - struct 可能有填充。这完全打破了对数组的任何重新解释。

Answer 2

形式上，struct 可能有填充，使其大小大于 1。

也就是说，正式地你不能reinterpret_cast 并且拥有完全可移植的代码，除了¹只有一个项目的数组。

但是在实践中，几年前有人问现在是否有任何编译器默认情况下会为struct T{ char x; }; 提供sizeof(T) > 1。我还没有看到任何例子。因此，在实践中，只需 static_assert 大小为 1，完全不用担心 static_assert 在某些系统上会失败。

即，

S const a1[] = { {'a'}, {'4'}, {'2'}, {'\0'} };
static_assert( sizeof( S ) == 1, "!" );

char const* const a2 = reinterpret_cast<char const*>( a1 );

for( int i = 0; i < 4; ++i )
{
    assert( a1[i].v == a2[i] );
}

---

由于可能以索引具有未定义行为的方式解释 C++14 及更高版本的标准，基于对“数组”的特殊解释，即指代某个原始数组，一个可能会以更笨拙和冗长但保证有效的方式编写此代码：

// I do not recommend this, but it's one way to avoid problems with some compiler that's
// based on an unreasonable, impractical interpretation of the C++14 standard.
#include <assert.h>
#include <new>

auto main() -> int
{
    struct S
    {
        char v;
    };

    int const compiler_specific_overhead    = 0;    // Redefine per compiler.
    // With value 0 for the overhead the internal workings here, what happens
    // in the machine code, is the same as /without/ this verbose work-around
    // for one impractical interpretation of the standard.
    int const n = 4;
    static_assert( sizeof( S ) == 1, "!" );
    char storage[n + compiler_specific_overhead]; 
    S* const a1 = ::new( storage ) S[n];
    assert( (void*)a1 == storage + compiler_specific_overhead );

    for( int i = 0; i < n; ++i ) { a1[i].v = "a42"[i]; }    //  Whatever

    // Here a2 points to items of the original `char` array, hence no indexing
    // UB even with impractical interpretation of the C++14 standard.
    // Note that the indexing-UB-free code from this point, is exactly the same
    // source code as the first code example that some claim has indexing UB.
    char const* const a2 = reinterpret_cast<char const*>( a1 );

    for( int i = 0; i < n; ++i )
    {
        assert( a1[i].v == a2[i] );
    }
}

---

^{注意事项：
¹ 该标准保证struct 的开头没有填充。}

Answer 3

a2[i]中的指针算法未定义，见C++14 5.7 [expr.add] p7:

对于加法或减法，如果表达式P 或Q 的类型为“pointer to cv T”，其中T 和数组元素类型不相似（4.5 )，行为未定义。 [注意：特别是，当数组包含派生类类型的对象时，指向基类的指针不能用于指针算术。 ——尾注]

由于这条规则，即使没有填充并且大小匹配，基于类型的别名分析允许编译器假设a1[i] 和a2[i] 不重叠（因为指针运算仅在@ 987654329@ 确实是 char 的数组，而不仅仅是具有相同大小和对齐方式的数组，如果它真的是 char 的数组，它必须是与 S 数组分开的对象。

Answer 4

如果源数据是恒定的，我想我会倾向于使用编译时转换：

#include <iostream>
#include <array>

struct S
{
    char v;
};

namespace detail {
    template<std::size_t...Is>
    constexpr auto to_cstring(const S* p, std::index_sequence<Is...>)
    {
        return std::array<char, sizeof...(Is)> {
            p[Is].v...
        };
    }
}

template<std::size_t N>
constexpr auto to_cstring(const S (&arr)[N])
{
    return detail::to_cstring(arr, std::make_index_sequence<N>());
}

int main()
{
    const /*expr if you wish*/ S a1[] = { {'a'}, {'4'}, {'2'}, {'\0'} };

    const /*expr if you wish*/ auto a2 = to_cstring(a1);


    for (int i = 0; i < 4; ++i)
        std::cout << std::boolalpha << (a1[i].v == a2[i]) << ' ';
}

输出：

true true true true

即使数据不是 constexpr，gcc 和 clang 也非常擅长像这样不断折叠复杂序列。