索引到结构是否合法？

不管代码有多“糟糕”，并假设对齐等在编译器/平台上都不是问题，这种未定义或破坏的行为是吗？

如果我有这样的结构：-

struct data
{
    int a, b, c;
};

struct data thing;

它是合法的访问a，b并c作为(&thing.a)[0]，(&thing.a)[1]和(&thing.a)[2]？

在每种情况下，我都会在每个编译器和平台上对其进行尝试，并在每个设置上对其进行“尝试”。我只是担心编译器可能不会意识到b和thing [1]是同一件事，并且存储到“ b”的内容可能会放在寄存器中，而thing [1]从内存中读取错误的值（例如）。在每种情况下，我都尝试过它做对了。（我当然知道并不能证明太多）

这不是我的代码；这是我必须使用的代码，我对这是不好的代码还是坏的代码很感兴趣，因为不同之处会影响我对其进行大量更改的优先级:)

标记为C和C ++。我主要是对C ++感兴趣，但对C也很感兴趣，只是出于兴趣。

这是非法的¹。这是C ++中的未定义行为。

您正在以数组方式获取成员，但这是C ++标准所说的（强调我的意思）：

[dcl.array / 1]： ...一个数组类型的对象包含一个连续分配的非空的N个子对象集，它们的类型为T。

但是，对于成员而言，没有这样的连续要求：

[class.mem / 17]： ...;实施对齐要求可能会导致两个相邻成员彼此之间不能立即分配 ...

尽管以上两个引号足以表明为什么按struct原样索引到a 并不是C ++标准定义的行为，但让我们举一个例子：看一下表达式(&thing.a)[2]-关于下标运算符：

[expr.post//expr.sub/1]： 后缀表达式后跟方括号中的表达式是后缀表达式。表达式之一应为类型“ T的数组”的glvalue或类型为“指向T的指针”的prvalue，另一个表达式应为无作用域枚举或整数类型的prvalue。结果为“ T”类型。类型“ T”应为完全定义的对象类型。66 表达式E1[E2]（根据定义）与((E1)+(E2))

深入研究以上引用的粗体文本：关于将整数类型添加到指针类型（请注意此处的重点）。

[expr.add / 4]：将具有整数类型的表达式添加到指针或从指针中减去时，结果将具有指针操作数的类型。如果表达式P指向元件x[i]的阵列对象x 与n个元素，表述P + J和J + P（其中，J具有值j）点到（可能-假设的）元件x[i + j] ，如果0 ≤ i + j ≤ n; 否则，行为是不确定的。...

注意if子句的数组要求；否则以上引用中的其他内容。该表达式显然不适合if子句；因此，未定义的行为。(&thing.a)[2]

附带说明一下：尽管我已经在各种编译器上对代码及其变体进行了广泛的实验，但它们在此处未引入任何填充（（有效））；从维护的角度来看，该代码非常脆弱。您仍应断言在执行此操作之前，实现已连续分配了成员。并保持边界:-)。但是它仍然是未定义的行为。

其他答案提供了一些可行的解决方法（具有定义的行为）。

正如评论中正确指出的，[basic.lval / 8]在我之前的编辑中不适用。谢谢@ 2501和@MM

¹：只有一个法律案例，您可以thing.a通过此terntern 访问结构的成员，请参见@Barry 对这个问题的回答。

否。在C中，即使没有填充，这也是未定义的行为。

导致不确定行为的原因是越界访问¹。当您有一个标量（结构中的成员a，b，c）并尝试将其用作数组²访问下一个假设元素时，即使在该地址。

但是，您可以使用struct对象的地址，并将偏移量计算为特定成员：

struct data thing = { 0 };
char* p = ( char* )&thing + offsetof( thing , b );
int* b = ( int* )p;
*b = 123;
assert( thing.b == 123 );

必须为每个成员单独完成此操作，但可以将其放入类似于数组访问的函数中。

¹（引自：ISO / IEC 9899：201x 6.5.6加法运算符8）
如果结果指向数组对象的最后一个元素之后的一个，则不应将其用作被评估的一元*运算符的操作数。

²（引自：ISO / IEC 9899：201x 6.5.6加法运算符7）
就这些运算符而言，指向不是数组元素的对象的指针的行为与指向数组第一个元素的指针的行为相同。长度为1的数组，对象的类型为其元素类型。

在C ++中，如果您确实需要它，请创建operator []：

struct data
{
    int a, b, c;
    int &operator[]( size_t idx ) {
        switch( idx ) {
            case 0 : return a;
            case 1 : return b;
            case 2 : return c;
            default: throw std::runtime_error( "bad index" );
        }
    }
};


data d;
d[0] = 123; // assign 123 to data.a

它不仅可以保证工作，而且用法更简单，您不需要编写不可读的表达式 (&thing.a)[0]

注意：假定您已经具有包含字段的结构，并且需要通过索引添加访问权限，则给出此答案。如果速度是一个问题，并且您可以更改结构，则可能会更有效：

struct data 
{
     int array[3];
     int &a = array[0];
     int &b = array[1];
     int &c = array[2];
};

此解决方案将更改结构的大小，因此您也可以使用方法：

struct data 
{
     int array[3];
     int &a() { return array[0]; }
     int &b() { return array[1]; }
     int &c() { return array[2]; }
};

对于c ++：如果需要在不知道成员名称的情况下访问成员，则可以使用指向成员变量的指针。

struct data {
  int a, b, c;
};

typedef int data::* data_int_ptr;

data_int_ptr arr[] = {&data::a, &data::b, &data::c};

data thing;
thing.*arr[0] = 123;

在ISO C99 / C11中，基于联合的类型绑定是合法的，因此您可以使用它代替索引非数组的指针（请参阅其他答案）。

ISO C ++不允许基于联合的类型处理。 作为扩展，GNU C ++确实可以，并且我认为一般不支持GNU扩展的其他一些编译器也支持联合类型对齐。但这并不能帮助您编写严格的可移植代码。

在当前版本的gcc和clang中，使用a switch(idx)来选择成员来编写C ++成员函数将优化编译时常数索引，但会为运行时索引产生可怕的分支asm。这没有什么天生的错误switch()。这只是当前编译器中未进行优化的错误。他们可以有效地编译Slava的switch（）函数。

解决方案/解决方法是用另一种方式做：给您的类/结构一个数组成员，并编写访问器函数以将名称附加到特定元素。

struct array_data
{
  int arr[3];

  int &operator[]( unsigned idx ) {
      // assert(idx <= 2);
      //idx = (idx > 2) ? 2 : idx;
      return arr[idx];
  }
  int &a(){ return arr[0]; } // TODO: const versions
  int &b(){ return arr[1]; }
  int &c(){ return arr[2]; }
};

我们可以在Godbolt编译器资源管理器上查看不同用例的asm输出。这些是完整的x86-64 System V功能，省略了尾随的RET指令，以更好地显示当它们内联时将得到的结果。ARM / MIPS /类似的东西。

# asm from g++6.2 -O3
int getb(array_data &d) { return d.b(); }
    mov     eax, DWORD PTR [rdi+4]

void setc(array_data &d, int val) { d.c() = val; }
    mov     DWORD PTR [rdi+8], esi

int getidx(array_data &d, int idx) { return d[idx]; }
    mov     esi, esi                   # zero-extend to 64-bit
    mov     eax, DWORD PTR [rdi+rsi*4]

相比之下，@ Slava使用switch()C ++ 的答案使asm成为运行时变量索引。（上一个Godbolt链接中的代码）。

int cpp(data *d, int idx) {
    return (*d)[idx];
}

    # gcc6.2 -O3, using `default: __builtin_unreachable()` to promise the compiler that idx=0..2,
    # avoiding an extra cmov for idx=min(idx,2), or an extra branch to a throw, or whatever
    cmp     esi, 1
    je      .L6
    cmp     esi, 2
    je      .L7
    mov     eax, DWORD PTR [rdi]
    ret
.L6:
    mov     eax, DWORD PTR [rdi+4]
    ret
.L7:
    mov     eax, DWORD PTR [rdi+8]
    ret

与基于C（或GNU C ++）联合的类型修剪版本相比，这显然是可怕的：

c(type_t*, int):
    movsx   rsi, esi                   # sign-extend this time, since I didn't change idx to unsigned here
    mov     eax, DWORD PTR [rdi+rsi*4]

在C ++中，这主要是未定义的行为（取决于哪个索引）。

来自[expr.unary.op]：

出于指针算术（5.7）和比较（5.9，5.10）的目的，不是以这种方式获取地址的数组元素的对象被视为属于一个类型为type的数组T。

&thing.a因此，该表达式被认为是一个1的数组int。

来自[expr.sub]：

该表达式E1[E2]（根据定义）与*((E1)+(E2))

从[expr.add]：

当将具有整数类型的表达式添加到指针或从指针中减去时，结果将具有指针操作数的类型。如果表达式P指向具有元素x[i]的数组对象x的n元素，则表达式if P + J和J + P（其中J的值是j）指向x[i + j]if （可能是假设的）元素0 <= i + j <= n；否则，行为是不确定的。

(&thing.a)[0]格式完美，因为它&thing.a被认为是大小为1的数组，因此我们采用第一个索引。那是允许的索引。

(&thing.a)[2]违反的前提下0 <= i + j <= n，因为我们有i == 0，j == 2，n == 1。简单地构造指针&thing.a + 2是未定义的行为。

(&thing.a)[1]是有趣的情况。它实际上并没有违反[expr.add]中的任何内容。我们被允许在数组的末尾取一个指针-这将是这样。在这里，我们转到[basic.compound]中的注释：

指向或超过对象末尾的指针类型的值表示对象53占用的存储器中第一个字节（1.7）的地址，或者对象占用的存储结束后的内存中第一个字节的地址， 分别。[注意：超出对象末尾（5.7）的指针不被认为指向可能位于该地址的对象类型的不相关对象。

因此，采用指针&thing.a + 1是已定义的行为，但取消引用它是未定义的，因为它没有指向任何内容。

这是未定义的行为。

C ++中有许多规则试图给编译器一些希望，使他们了解自己在做什么，以便它可以推理并优化它。

关于别名（通过两种不同的指针类型访问数据），数组边界等有一些规则。

当您拥有一个变量时x，它不是数组的成员这一事实意味着编译器可以假定没有[]基于数组的访问可以修改它。因此，不必每次使用时都不断从内存中重新加载数据。只有有人可以从它的名字上修改它。

因此(&thing.a)[1]，编译器可以假定它不引用thing.b。它可以利用这一事实对读和写进行重新排序，从而thing.b使您想要执行的操作无效，而不会使您实际告诉其执行的操作无效。

一个典型的例子就是抛弃const。

const int x = 7;
std::cout << x << '\n';
auto ptr = (int*)&x;
*ptr = 2;
std::cout << *ptr << "!=" << x << '\n';
std::cout << ptr << "==" << &x << '\n';

在这里，您通常会得到一个编译器，说7然后2！= 7，然后是两个相同的指针；尽管事实ptr指向x。x当您要求的值时，编译器会认为这是一个常量值，因此不必理会它x。

但是，当您使用的地址时x，会强制其存在。然后，您丢弃const，并对其进行修改。因此，内存中的实际位置x已被修改，编译器可以自由地在读取时不实际读取它x！

编译器可能足够聪明，可以弄清楚如何甚至避免遵循ptr阅读规则*ptr，但往往不是。ptr = ptr+argc-1如果优化器比您更聪明，请随时使用或使用此类混淆。

您可以提供一个operator[]获取正确项目的自定义。

int& operator[](std::size_t);
int const& operator[](std::size_t) const;

两者都有用。

这是一种使用代理类按名称访问成员数组中元素的方法。它是非常C ++的语言，除了语法首选项外，与ref返回访问器函数相比没有任何好处。这使->操作员无法访问作为成员的元素，因此，需要接受的既是既要不喜欢访问器（d.a() = 5;）的语法，又要允许->与非指针对象一起使用，这是可以接受的。我希望这也会使对代码不熟悉的读者感到困惑，因此，这可能比您要投入生产的东西更巧妙。

Data此代码中的结构还包括下标运算符的重载，以访问其ar数组成员内的索引元素以及begin和end函数以进行迭代。而且，所有这些都非标准和const版本都被重载，为了完整性，我认为必须将其包含在内。

当使用Datas ->通过名称访问元素时（例如：）my_data->b = 5;，将Proxy返回一个对象。然后，由于此Proxy右值不是指针，因此将->自动调用其自身的运算符，该运算符将返回指向自身的指针。这样，Proxy对象被实例化并在初始表达式的求值期间保持有效。

一个的敷设渠道Proxy对象填充其3个基准构件a，b并c根据在构造传递一个指针，其被假定为指向包含至少3个值，其类型被给出为模板参数的缓冲器T。因此，与其使用作为Data类成员的命名引用，->还不如通过在访问点填充引用来节省内存（但不幸的是，使用而不是.运算符）。

为了测试编译器的优化程序消除使用引入的所有间接调用的效果Proxy，下面的代码包括2个版本的main()。该#if 1版本使用->和[]运算符，并且该#if 0版本执行等效的过程集，但只能直接访问Data::ar。

该Nci()函数生成用于初始化数组元素的运行时整数值，从而防止优化器仅将常量值直接插入每个std::cout <<调用中。

对于gcc 6.2，使用-O3，这两个版本的都会main()生成相同的程序集（在第一个进行比较之前#if 1和#if 0之后进行切换main()）：https : //godbolt.org/g/QqRWZb

#include <iostream>
#include <ctime>

template <typename T>
class Proxy {
public:
    T &a, &b, &c;
    Proxy(T* par) : a(par[0]), b(par[1]), c(par[2]) {}
    Proxy* operator -> () { return this; }
};

struct Data {
    int ar[3];
    template <typename I> int& operator [] (I idx) { return ar[idx]; }
    template <typename I> const int& operator [] (I idx) const { return ar[idx]; }
    Proxy<int>       operator -> ()       { return Proxy<int>(ar); }
    Proxy<const int> operator -> () const { return Proxy<const int>(ar); }
    int* begin()             { return ar; }
    const int* begin() const { return ar; }
    int* end()             { return ar + sizeof(ar)/sizeof(int); }
    const int* end() const { return ar + sizeof(ar)/sizeof(int); }
};

// Nci returns an unpredictible int
inline int Nci() {
    static auto t = std::time(nullptr) / 100 * 100;
    return static_cast<int>(t++ % 1000);
}

#if 1
int main() {
    Data d = {Nci(), Nci(), Nci()};
    for(auto v : d) { std::cout << v << ' '; }
    std::cout << "\n";
    std::cout << d->b << "\n";
    d->b = -5;
    std::cout << d[1] << "\n";
    std::cout << "\n";

    const Data cd = {Nci(), Nci(), Nci()};
    for(auto v : cd) { std::cout << v << ' '; }
    std::cout << "\n";
    std::cout << cd->c << "\n";
    //cd->c = -5;  // error: assignment of read-only location
    std::cout << cd[2] << "\n";
}
#else
int main() {
    Data d = {Nci(), Nci(), Nci()};
    for(auto v : d.ar) { std::cout << v << ' '; }
    std::cout << "\n";
    std::cout << d.ar[1] << "\n";
    d->b = -5;
    std::cout << d.ar[1] << "\n";
    std::cout << "\n";

    const Data cd = {Nci(), Nci(), Nci()};
    for(auto v : cd.ar) { std::cout << v << ' '; }
    std::cout << "\n";
    std::cout << cd.ar[2] << "\n";
    //cd.ar[2] = -5;
    std::cout << cd.ar[2] << "\n";
}
#endif

如果读取值足够，并且效率不是问题，或者您信任编译器可以很好地进行优化，或者struct仅为3个字节，则可以放心地执行此操作：

char index_data(const struct data *d, size_t index) {
  assert(sizeof(*d) == offsetoff(*d, c)+1);
  assert(index < sizeof(*d));
  char buf[sizeof(*d)];
  memcpy(buf, d, sizeof(*d));
  return buf[index];
}

对于仅C ++版本，您可能要使用static_assert来验证其struct data具有标准布局，并可能在无效索引上引发异常。

这是非法的，但是有一种解决方法：

struct data {
    union {
        struct {
            int a;
            int b;
            int c;
        };
        int v[3];
    };
};

现在您可以索引v：