Apakah legal untuk mengindeks ke dalam struct?

Terlepas dari seberapa 'buruk' kode tersebut, dan dengan asumsi bahwa penyelarasan dll bukanlah masalah pada kompiler / platform, apakah ini perilaku yang tidak terdefinisi atau rusak?

Jika saya memiliki struct seperti ini: -

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

struct data thing;

Apakah hukum untuk mengakses a, bdan csebagai (&thing.a)[0], (&thing.a)[1], dan (&thing.a)[2]?

Dalam setiap kasus, pada setiap kompiler dan platform saya mencobanya, dengan setiap pengaturan saya mencobanya 'bekerja'. Saya hanya khawatir bahwa kompilator mungkin tidak menyadari bahwa b dan thing [1] adalah hal yang sama dan penyimpanan ke 'b' mungkin dimasukkan ke dalam register dan thing [1] membaca nilai yang salah dari memori (misalnya). Dalam setiap kasus yang saya coba lakukan hal yang benar. (Saya menyadari tentu saja itu tidak membuktikan banyak)

Ini bukan kode saya; itu kode yang harus saya tangani , saya tertarik apakah ini kode yang buruk atau kode rusak karena perbedaannya memengaruhi prioritas saya untuk banyak mengubahnya :)

Diberi tag C dan C ++. Saya kebanyakan tertarik pada C ++ tetapi juga C jika berbeda, hanya untuk minat.

Itu ilegal ¹ . Itu adalah perilaku yang tidak ditentukan di C ++.

Anda mengambil anggota dalam gaya array, tetapi inilah yang dikatakan standar C ++ (penekanan saya):

[dcl.array / 1] : ... Objek bertipe array berisikumpulan N subobjek tipe T yang tidak kosong dan dialokasikan secara berdekatan ...

Namun, untuk anggota, tidak ada persyaratan yang berdekatan :

[class.mem / 17] : ...; Persyaratan penyelarasan implementasi dapat menyebabkan dua anggota yang berdekatan tidak dialokasikan segera setelah satu sama lain ...

Meskipun dua tanda kutip di atas seharusnya cukup untuk memberi petunjuk mengapa pengindeksan menjadi structseperti yang Anda lakukan bukanlah perilaku yang ditentukan oleh standar C ++, mari kita pilih satu contoh: lihat ekspresi (&thing.a)[2]- Mengenai operator subskrip:

[expr.post//expr.sub/1] : Ekspresi postfix yang diikuti dengan ekspresi dalam tanda kurung siku adalah ekspresi postfix. Salah satu ekspresi harus menjadi nilai gl dari tipe "larik T" atau nilai awal dari tipe "penunjuk ke T" dan yang lainnya harus menjadi nilai awal dari pencacahan tanpa batas atau tipe integral. Hasilnya adalah tipe "T". Tipe "T" haruslah tipe objek yang sepenuhnya terdefinisi.66 Ekspresi E1[E2]ini identik (menurut definisi)((E1)+(E2))

Menggali teks tebal dari kutipan di atas: tentang menambahkan tipe integral ke tipe penunjuk (perhatikan penekanannya di sini) ..

[expr.add / 4] : Jika ekspresi yang memiliki tipe integral ditambahkan atau dikurangkan dari pointer, hasilnya memiliki tipe operan pointer. Jika ekspresiPpoin untuk elemenx[i]dari array objekx dengan n elemen, ekspresiP + JdanJ + P(di manaJmemiliki nilaij) titik ke (mungkin-hipotetis) elemenx[i + j] jika0 ≤ i + j ≤ n; jika tidak , perilaku tidak terdefinisi. ...

Perhatikan persyaratan larik untuk klausa if ; lain sebaliknya dalam kutipan di atas. Ekspresi tersebut (&thing.a)[2]jelas tidak memenuhi syarat untuk klausa if ; Karenanya, Perilaku Tidak Terdefinisi.

Di samping catatan: Meskipun saya telah bereksperimen secara ekstensif kode dan variasinya pada berbagai kompiler dan mereka tidak memperkenalkan padding apa pun di sini, ( berhasil ); dari sudut pandang pemeliharaan, kode ini sangat rapuh. Anda masih harus menegaskan bahwa implementasi mengalokasikan anggota secara berdekatan sebelum melakukan ini. Dan tetap terikat :-). Tapi perilakunya masih belum ditentukan ....

Beberapa solusi yang layak (dengan perilaku yang ditentukan) telah disediakan oleh jawaban lain.

Seperti yang ditunjukkan dengan benar di komentar, [basic.lval / 8] , yang saya edit sebelumnya tidak berlaku. Terima kasih @ 2501 dan @MM

¹ : Lihat jawaban @ Barry atas pertanyaan ini untuk satu-satunya kasus hukum di mana Anda dapat mengakses thing.aanggota struct melalui parttern ini.

Tidak. Di C, ini adalah perilaku yang tidak terdefinisi meskipun tidak ada padding.

Hal yang menyebabkan perilaku tidak terdefinisi adalah akses di luar batas ¹ . Ketika Anda memiliki skalar (anggota a, b, c di struct) dan mencoba menggunakannya sebagai larik ² untuk mengakses elemen hipotetis berikutnya, Anda menyebabkan perilaku tidak terdefinisi, bahkan jika kebetulan ada objek lain dengan tipe yang sama di alamat itu.

Namun Anda dapat menggunakan alamat objek struct dan menghitung offset menjadi anggota tertentu:

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

Ini harus dilakukan untuk setiap anggota secara individual, tetapi dapat dimasukkan ke dalam fungsi yang menyerupai akses array.

¹ (Dikutip dari: ISO / IEC 9899: 201x 6.5.6 Operator aditif 8)
Jika hasil menunjuk satu melewati elemen terakhir dari objek array, itu tidak boleh digunakan sebagai operand dari operator unary * yang dievaluasi.

² (Dikutip dari: ISO / IEC 9899: 201x 6.5.6 Operator aditif 7)
Untuk keperluan operator ini, penunjuk ke objek yang bukan elemen larik berperilaku sama seperti penunjuk ke elemen pertama dari sebuah array dengan panjang satu dengan tipe objek sebagai tipe elemennya.

Di C ++ jika Anda benar-benar membutuhkannya - buat 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

ini tidak hanya dijamin berfungsi tetapi penggunaannya lebih sederhana, Anda tidak perlu menulis ekspresi yang tidak dapat dibaca (&thing.a)[0]

Catatan: jawaban ini diberikan dengan asumsi Anda sudah memiliki struktur dengan bidang, dan Anda perlu menambahkan akses melalui indeks. Jika kecepatan menjadi masalah dan Anda dapat mengubah strukturnya, ini bisa menjadi lebih efektif:

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

Solusi ini akan mengubah ukuran struktur sehingga Anda dapat menggunakan metode juga:

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

Untuk c ++: Jika Anda perlu mengakses anggota tanpa mengetahui namanya, Anda dapat menggunakan penunjuk ke variabel anggota.

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;

Dalam ISO C99 / C11, jenis-punning berbasis union adalah legal, jadi Anda dapat menggunakannya daripada mengindeks pointer ke non-array (lihat berbagai jawaban lain).

ISO C ++ tidak mengizinkan jenis punning berbasis gabungan. GNU C ++ memang, sebagai ekstensi , dan saya pikir beberapa kompiler lain yang tidak mendukung ekstensi GNU secara umum mendukung union type-punning. Tetapi itu tidak membantu Anda menulis kode yang sangat portabel.

Dengan versi gcc dan clang saat ini, menulis fungsi anggota C ++ menggunakan a switch(idx)untuk memilih anggota akan mengoptimalkan indeks konstan waktu kompilasi, tetapi akan menghasilkan asm bercabang yang mengerikan untuk indeks waktu proses. Tidak ada yang salah dengan switch()hal ini; ini hanyalah bug pengoptimalan yang terlewat di kompiler saat ini. Mereka bisa mengkompilasi fungsi switch () Slava secara efisien.

Solusi / solusi untuk ini adalah melakukannya dengan cara lain: berikan kelas / struct Anda anggota array, dan tulis fungsi pengakses untuk melampirkan nama ke elemen tertentu.

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]; }
};

Kita dapat melihat keluaran asm untuk kasus penggunaan yang berbeda, pada penjelajah kompilator Godbolt . Ini adalah fungsi Sistem V x86-64 lengkap, dengan instruksi RET tambahan dihilangkan untuk lebih menunjukkan apa yang Anda dapatkan ketika mereka sebaris. ARM / MIPS / apa pun yang serupa.

# 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]

Sebagai perbandingan, jawaban @ Slava menggunakan a switch()for C ++ membuat asm seperti ini untuk indeks variabel runtime. (Kode di tautan Godbolt sebelumnya).

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

Ini jelas mengerikan, dibandingkan dengan versi pelesetan tipe berbasis serikat C (atau 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]

Di C ++, ini sebagian besar perilaku yang tidak ditentukan (tergantung indeks mana).

Dari [expr.unary.op]:

Untuk keperluan aritmatika pointer (5.7) dan perbandingan (5.9, 5.10), sebuah objek yang bukan elemen array yang alamatnya diambil dengan cara ini dianggap milik array dengan satu elemen tipe T.

Dengan &thing.ademikian, ekspresi tersebut dianggap merujuk ke larik satu int.

Dari [expr.sub]:

Ekspresi E1[E2]tersebut identik (menurut definisi) dengan*((E1)+(E2))

Dan dari [expr.add]:

Ketika ekspresi yang memiliki tipe integral ditambahkan ke atau dikurangkan dari pointer, hasilnya memiliki tipe operan pointer. Jika ekspresi Pmenunjuk ke elemen x[i]objek larik xdengan nelemen, ekspresi P + Jdan J + P(di mana Jmemiliki nilai j) mengarah ke elemen (kemungkinan hipotetis) x[i + j]jika0 <= i + j <= n ; jika tidak, perilaku tidak terdefinisi.

(&thing.a)[0] terbentuk sempurna karena &thing.a dianggap sebagai larik berukuran 1 dan kami mengambil indeks pertama tersebut. Itu adalah indeks yang diizinkan untuk diambil.

(&thing.a)[2]melanggar prasyarat bahwa 0 <= i + j <= n, karena kita memiliki i == 0, j == 2, n == 1. Cukup membuat penunjuk&thing.a + 2 adalah perilaku yang tidak ditentukan.

(&thing.a)[1]adalah kasus yang menarik. Itu sebenarnya tidak melanggar apa pun di [expr.add]. Kami diizinkan untuk mengambil penunjuk satu melewati akhir larik - yang ini akan terjadi. Di sini, kita beralih ke catatan di [basic.compound]:

Nilai tipe penunjuk yang merupakan penunjuk ke atau melewati ujung suatu objek mewakili alamat byte pertama dalam memori (1.7) yang ditempati oleh objek53 atau byte pertama dalam memori setelah akhir penyimpanan yang ditempati oleh objek , masing-masing. [Catatan: Sebuah pointer yang melewati akhir suatu objek (5.7) tidak dianggap menunjuk ke objek yang tidak terkait dari tipe objek yang mungkin terletak di alamat itu.

Oleh karena itu, mengambil penunjuk &thing.a + 1adalah perilaku yang didefinisikan, tetapi mendereferensi itu tidak ditentukan karena tidak menunjuk ke apa pun.

Ini adalah perilaku yang tidak terdefinisi.

Ada banyak aturan dalam C ++ yang mencoba memberi kompiler harapan untuk memahami apa yang Anda lakukan, sehingga dapat mempertimbangkannya dan mengoptimalkannya.

Ada aturan tentang aliasing (mengakses data melalui dua jenis penunjuk yang berbeda), batas array, dll.

Jika Anda memiliki variabel x, fakta bahwa variabel tersebut bukan anggota array berarti kompilator dapat berasumsi bahwa tidak ada []akses array berbasis yang dapat mengubahnya. Jadi tidak harus terus-menerus memuat ulang data dari memori setiap kali Anda menggunakannya; hanya jika seseorang bisa mengubahnya dari namanya .

Dengan demikian (&thing.a)[1]dapat diasumsikan oleh compiler untuk tidak merujuk thing.b. Ia dapat menggunakan fakta ini untuk menyusun ulang baca dan tulis kething.b , membatalkan apa yang Anda ingin lakukan tanpa membatalkan apa yang sebenarnya Anda perintahkan.

Contoh klasik dari ini adalah membuang 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';

di sini Anda biasanya mendapatkan kompiler yang mengatakan 7 lalu 2! = 7, dan kemudian dua petunjuk identik; terlepas dari fakta yang ptrmenunjuk x. Kompilator menganggap fakta bahwa xnilai konstan tidak perlu repot-repot membacanya saat Anda meminta nilaix .

Tetapi ketika Anda mengambil alamat x, Anda memaksanya untuk ada. Anda kemudian membuang const, dan memodifikasinya. Jadi lokasi sebenarnya dalam memori xyang telah dimodifikasi, compiler bebas untuk tidak benar-benar membacanya saat membacax !

Kompiler mungkin menjadi cukup pintar untuk mencari tahu bagaimana menghindari mengikuti ptruntuk membaca *ptr, tetapi seringkali tidak. Silakan pergi dan gunakanptr = ptr+argc-1 atau kebingungan seperti itu jika pengoptimal semakin pintar dari Anda.

Anda bisa memberikan kebiasaan operator[]yang mendapatkan barang yang tepat.

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

memiliki keduanya berguna.

Inilah cara untuk menggunakan kelas proxy untuk mengakses elemen dalam array anggota dengan nama. Ini sangat C ++, dan tidak memiliki manfaat vs. fungsi aksesor yang mengembalikan ref, kecuali untuk preferensi sintaksis. Ini membebani ->operator untuk mengakses elemen sebagai anggota, jadi agar dapat diterima, seseorang harus tidak menyukai sintaksis aksesor ( d.a() = 5;), serta mentolerir penggunaan-> dengan objek non-pointer. Saya berharap ini mungkin juga membingungkan pembaca yang tidak terbiasa dengan kode, jadi ini mungkin lebih merupakan trik rapi daripada sesuatu yang ingin Anda masukkan ke dalam produksi.

The Datastruct dalam kode ini juga termasuk overloads untuk operator subscript, untuk elemen akses diindeks dalam yang aranggota array, serta begindanend fungsi, untuk iterasi. Juga, semua ini kelebihan beban dengan versi non-const dan const, yang menurut saya perlu disertakan untuk kelengkapan.

Ketika Data's ->digunakan untuk mengakses elemen dengan nama (seperti ini: my_data->b = 5;), sebuah Proxyobjek dikembalikan. Kemudian, karena nilai Proxyr ini bukan penunjuk, ->operatornya sendiri disebut rantai otomatis, yang mengembalikan penunjuk ke dirinya sendiri. Dengan cara ini, Proxyobjek dibuat instance-nya dan tetap valid selama evaluasi ekspresi awal.

Konstruksi Proxyobjek mengisi 3 anggota referensinya a, bdan cmenurut pointer yang diteruskan dalam konstruktor, yang diasumsikan mengarah ke buffer yang berisi setidaknya 3 nilai yang tipenya diberikan sebagai parameter template T. Jadi alih-alih menggunakan referensi bernama yang merupakan anggota Datakelas, ini menghemat memori dengan mengisi referensi pada titik akses (tapi sayangnya, menggunakan ->dan bukan. operator).

Untuk menguji seberapa baik pengoptimal compiler menghilangkan semua tipu muslihat yang diperkenalkan oleh penggunaan Proxy, kode di bawah ini menyertakan 2 versi main(). The #if 1Versi menggunakan ->dan []operator, dan #if 0Melakukan versi setara set prosedur, tetapi hanya dengan langsung mengaksesData::ar .

The Nci()Fungsi menghasilkan nilai integer runtime untuk menginisialisasi elemen array, yang mencegah optimizer dari hanya memasukkan nilai-nilai konstan langsung ke masing-masingstd::cout << panggilan.

Untuk gcc 6.2, menggunakan -O3, kedua versi main()menghasilkan rakitan yang sama (beralih antara #if 1dan #if 0sebelum yang pertama main()untuk membandingkan): 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

Jika membaca nilai sudah cukup, dan efisiensi bukan masalah, atau jika Anda memercayai kompiler Anda untuk mengoptimalkan semuanya dengan baik, atau jika struct hanya 3 byte, Anda dapat melakukan ini dengan aman:

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];
}

Untuk versi C ++ saja, Anda mungkin ingin menggunakan static_assertuntuk memverifikasi bahwa struct datamemiliki tata letak standar, dan mungkin melemparkan pengecualian pada indeks yang tidak valid.

Ini ilegal, tetapi ada solusi lain:

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

Sekarang Anda dapat mengindeks v: