Mengapa array referensi ilegal?

Kode berikut tidak dikompilasi.

int a = 1, b = 2, c = 3;
int& arr[] = {a,b,c,8};

Apa yang dikatakan standar C ++ tentang ini?

Saya tahu saya bisa mendeklarasikan kelas yang berisi referensi, lalu membuat array kelas itu, seperti yang ditunjukkan di bawah ini. Tetapi saya benar-benar ingin tahu mengapa kode di atas tidak dapat dikompilasi.

struct cintref
{
    cintref(const int & ref) : ref(ref) {}
    operator const int &() { return ref; }
private:
    const int & ref;
    void operator=(const cintref &);
};

int main() 
{
  int a=1,b=2,c=3;
  //typedef const int &  cintref;
  cintref arr[] = {a,b,c,8};
}

Dimungkinkan untuk menggunakan struct cintrefalih-alih const int &mensimulasikan array referensi.

Menjawab pertanyaan Anda tentang standar saya dapat mengutip C ++ Standar §8.3.2 / 4 :

Tidak akan ada referensi ke referensi, tidak ada array referensi , dan tidak ada petunjuk ke referensi.

Referensi bukan objek. Mereka tidak memiliki penyimpanan sendiri, mereka hanya mereferensikan objek yang ada. Untuk alasan ini, tidak masuk akal untuk memiliki array referensi.

Jika Anda ingin ringan objek yang referensi objek lain maka Anda dapat menggunakan pointer. Anda hanya akan dapat menggunakan a structdengan anggota referensi sebagai objek dalam array jika Anda memberikan inisialisasi eksplisit untuk semua anggota referensi untuk semua structinstance. Referensi tidak dapat secara default diinisialisasi.

Sunting: Seperti catatan jia3ep, di bagian standar tentang deklarasi ada larangan eksplisit pada array referensi.

Ini diskusi yang menarik. Array yang jelas jelas ilegal, tetapi IMHO alasan mengapa tidak sesederhana mengatakan 'mereka bukan benda' atau 'mereka tidak memiliki ukuran'. Saya akan menunjukkan bahwa array itu sendiri bukan objek yang lengkap dalam C / C ++ - jika Anda keberatan, coba instantiating beberapa kelas template stl menggunakan array sebagai parameter template 'class', dan lihat apa yang terjadi. Anda tidak dapat mengembalikannya, menetapkannya, meneruskannya sebagai parameter. (param array diperlakukan sebagai pointer). Tetapi adalah legal untuk membuat array dari array. Referensi memang memiliki ukuran yang dapat dan harus dihitung oleh kompilator - Anda tidak dapat sizeof () referensi, tetapi Anda dapat membuat struct yang hanya berisi referensi. Ini akan memiliki ukuran yang cukup untuk memuat semua pointer yang mengimplementasikan referensi. Kamu bisa'

struct mys {
 int & a;
 int & b;
 int & c;
};
...
int ivar1, ivar2, arr[200];
mys my_refs = { ivar1, ivar2, arr[12] };

my_refs.a += 3  ;  // add 3 to ivar1

Bahkan Anda dapat menambahkan baris ini ke definisi struct

struct mys {
 ...
 int & operator[]( int i ) { return i==0?a : i==1? b : c; }
};

... dan sekarang saya memiliki sesuatu yang terlihat BANYAK seperti serangkaian referensi:

int ivar1, ivar2, arr[200];
mys my_refs = { ivar1, ivar2, arr[12] };

my_refs[1] = my_refs[2]  ;  // copy arr[12] to ivar2
&my_refs[0];               // gives &my_refs.a == &ivar1

Sekarang, ini bukan array nyata, ini kelebihan operator; itu tidak akan melakukan hal-hal yang biasanya dilakukan array seperti sizeof (arr) / sizeof (arr [0]), misalnya. Tapi itu tidak persis apa yang saya ingin array referensi lakukan, dengan C ++ legal. Kecuali (a) itu sulit untuk mengatur lebih dari 3 atau 4 elemen, dan (b) melakukan perhitungan menggunakan sekelompok? , tetapi tetap mengindeks). Saya ingin melihat tipe 'array referensi' yang sangat terbatas yang sebenarnya dapat melakukan ini. Yaitu array referensi tidak akan diperlakukan sebagai array umum dari hal-hal yang merupakan referensi, tetapi akan menjadi 'array-referensi-baru' buat dengan templat).

ini mungkin akan berhasil, jika Anda tidak keberatan dengan jenis jahat ini: menyusun kembali '* this' sebagai array int * dan mengembalikan referensi yang dibuat dari satu: (tidak disarankan, tetapi ini menunjukkan bagaimana 'array' yang tepat) akan bekerja):

 int & operator[]( int i ) { return *(reinterpret_cast<int**>(this)[i]); }

Komentar untuk hasil edit Anda:

Solusi yang lebih baik adalah std::reference_wrapper.

Detail: http://www.cplusplus.com/reference/functional/reference_wrapper/

Contoh:

#include <iostream>
#include <functional>
using namespace std;

int main() {
    int a=1,b=2,c=3,d=4;
    using intlink = std::reference_wrapper<int>;
    intlink arr[] = {a,b,c,d};
    return 0;
}

Array secara implisit dapat dikonversi menjadi pointer, dan pointer-to-reference ilegal di C ++

Diberikan int& arr[] = {a,b,c,8}; , apa itu sizeof(*arr)?

Di tempat lain, referensi diperlakukan hanya sebagai hal itu sendiri, jadi sizeof(*arr)seharusnya begitu saja sizeof(int). Tapi ini akan membuat array pointer aritmatika pada array ini salah (dengan asumsi referensi yang lebar tidak sama dengan int). Untuk menghilangkan ambiguitas, itu dilarang.

Karena seperti yang banyak dikatakan di sini, referensi bukanlah objek. mereka hanyalah alias. Benar beberapa kompiler mungkin mengimplementasikannya sebagai pointer, tetapi standar tidak memaksa / menentukan itu. Dan karena referensi bukan objek, Anda tidak dapat mengarahkannya. Menyimpan elemen dalam array berarti ada beberapa jenis alamat indeks (yaitu, menunjuk ke elemen pada indeks tertentu); dan itulah sebabnya Anda tidak dapat memiliki array referensi, karena Anda tidak dapat mengarahkannya.

Gunakan boost :: reference_wrapper, atau boost :: tuple sebagai gantinya; atau hanya petunjuk.

Saya percaya jawabannya sangat sederhana dan ada hubungannya dengan aturan referensi semantik dan bagaimana array ditangani dalam C ++.

Singkatnya: Referensi dapat dianggap sebagai struct yang tidak memiliki konstruktor default, jadi semua aturan yang sama berlaku.

1) Secara semantik, referensi tidak memiliki nilai default. Referensi hanya dapat dibuat dengan merujuk sesuatu. Referensi tidak memiliki nilai untuk mewakili tidak adanya referensi.

2) Saat mengalokasikan array ukuran X, program membuat koleksi objek yang diinisialisasi default. Karena referensi tidak memiliki nilai default, membuat array seperti itu secara semantik ilegal.

Aturan ini juga berlaku untuk struct / kelas yang tidak memiliki konstruktor default. Contoh kode berikut tidak dikompilasi:

struct Object
{
    Object(int value) { }
};

Object objects[1]; // Error: no appropriate default constructor available

Anda bisa cukup dekat dengan struct template ini. Namun, Anda perlu menginisialisasi dengan ekspresi yang mengarah ke T, bukan T; jadi, meskipun Anda dapat dengan mudah membuat 'fake_constref_array' dengan cara yang sama, Anda tidak akan dapat mengikatnya ke nilai seperti yang dilakukan dalam contoh OP ('8');

#include <stdio.h>

template<class T, int N> 
struct fake_ref_array {
   T * ptrs[N];
  T & operator [] ( int i ){ return *ptrs[i]; }
};

int A,B,X[3];

void func( int j, int k)
{
  fake_ref_array<int,3> refarr = { &A, &B, &X[1] };
  refarr[j] = k;  // :-) 
   // You could probably make the following work using an overload of + that returns
   // a proxy that overloads *. Still not a real array though, so it would just be
   // stunt programming at that point.
   // *(refarr + j) = k  
}

int
main()
{
    func(1,7);  //B = 7
    func(2,8);     // X[1] = 8
    printf("A=%d B=%d X = {%d,%d,%d}\n", A,B,X[0],X[1],X[2]);
        return 0;
}

-> A = 0 B = 7 X = {0,8,0}

Objek referensi tidak memiliki ukuran. Jika Anda menulis sizeof(referenceVariable), itu akan memberi Anda ukuran objek yang dirujuk referenceVariable, bukan referensi itu sendiri. Ia tidak memiliki ukuran sendiri, itulah sebabnya kompiler tidak dapat menghitung berapa ukuran array yang diperlukan.

Ketika Anda menyimpan sesuatu dalam sebuah array, ukurannya perlu diketahui (karena pengindeksan array bergantung pada ukurannya). Per standar C ++ Tidak ditentukan apakah referensi membutuhkan penyimpanan atau tidak, karena itu pengindeksan array referensi tidak mungkin dilakukan.

Hanya untuk menambah semua percakapan. Karena array memerlukan lokasi memori berturut-turut untuk menyimpan item, jadi jika kita membuat array referensi maka tidak dijamin bahwa mereka akan berada di lokasi memori berturut-turut sehingga mengakses akan menjadi masalah dan karenanya kita bahkan tidak dapat menerapkan semua operasi matematika pada Himpunan.

Pertimbangkan berbagai petunjuk. Pointer adalah alamat; jadi ketika Anda menginisialisasi array, Anda memberi tahu komputer secara analog, "alokasikan blok memori ini untuk menampung angka-angka X ini (yang merupakan alamat barang-barang lainnya)." Kemudian jika Anda mengubah salah satu dari pointer, Anda hanya mengubah apa yang ditunjukkannya; itu masih alamat numerik yang dengan sendirinya duduk di tempat yang sama.

Referensi analog dengan alias. Jika Anda mendeklarasikan serangkaian referensi, Anda pada dasarnya akan memberi tahu komputer, "alokasikan gumpalan memori amorf ini yang terdiri dari semua item berbeda yang tersebar di sekitarnya."

Sebenarnya, ini adalah campuran dari sintaks C dan C ++.

Anda harus baik menggunakan array C murni, yang tidak dapat referensi, karena referensi merupakan bagian dari C ++ saja. Atau Anda menggunakan cara C ++ dan menggunakan kelas std::vectoratau std::arrayuntuk tujuan Anda.

Adapun bagian yang diedit: Meskipun structmerupakan elemen dari C, Anda mendefinisikan fungsi konstruktor dan operator, yang membuatnya menjadi C ++ class. Akibatnya, Anda structtidak akan dikompilasi dalam C murni!