Dlaczego tablice odniesień są nielegalne?

Poniższy kod nie jest kompilowany.

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

Co na ten temat mówi standard C ++?

Wiem, że mógłbym zadeklarować klasę, która zawiera odniesienie, a następnie utworzyć tablicę tej klasy, jak pokazano poniżej. Ale naprawdę chcę wiedzieć, dlaczego powyższy kod się nie kompiluje.

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

Możliwe jest użycie struct cintrefzamiast const int &symulacji tablicy odniesień.

Odpowiadając na Twoje pytanie o standard mogę przytoczyć C ++ Standard §8.3.2 / 4 :

Nie będzie żadnych odniesień do odniesień, żadnych tablic odniesień ani wskaźników do odniesień.

Referencje nie są obiektami. Nie mają własnego magazynu, po prostu odwołują się do istniejących obiektów. Z tego powodu tablice odwołań nie mają sensu.

Jeśli potrzebujesz lekkiego obiektu, który odwołuje się do innego obiektu, możesz użyć wskaźnika. Będziesz mógł używać elementu structreferencyjnego jako obiektów w tablicach tylko wtedy, gdy podasz jawną inicjalizację dla wszystkich członków odniesienia dla wszystkich structinstancji. Odwołania nie mogą być inicjalizowane domyślnie.

Edycja: Jak zauważa jia3ep, w standardowej sekcji dotyczącej deklaracji istnieje wyraźny zakaz dotyczący tablic odniesień.

To interesująca dyskusja. Oczywiście tablice referencji są całkowicie nielegalne, ale IMHO powód, dla którego nie jest tak prosty, jak powiedzenie „nie są obiektami” lub „nie mają rozmiaru”. Zwróciłbym uwagę, że same tablice nie są pełnoprawnymi obiektami w C / C ++ - jeśli sprzeciwiasz się temu, spróbuj utworzyć instancję niektórych klas szablonów stl, używając tablicy jako parametru szablonu „class” i zobacz, co się stanie. Nie możesz ich zwrócić, przypisać, przekazać jako parametry. (parametr tablicy jest traktowany jako wskaźnik). Ale tworzenie tablic tablic jest legalne. Referencje mają rozmiar, który kompilator może i musi obliczyć - nie możesz sizeof () odwołania, ale możesz utworzyć strukturę zawierającą tylko odwołania. Będzie miał wystarczający rozmiar, aby pomieścić wszystkie wskaźniki, które implementują odwołania. Możesz'

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

W rzeczywistości możesz dodać tę linię do definicji struktury

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

... a teraz mam coś, co wygląda DUŻO jak tablica referencji:

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

Otóż, to nie jest prawdziwa tablica, to przeciążenie operatora; nie zrobi rzeczy, które normalnie robią tablice, na przykład sizeof (arr) / sizeof (arr [0]). Ale robi dokładnie to, czego chcę, aby robił szereg odniesień, z całkowicie legalnym C ++. Z wyjątkiem (a) uciążliwa jest konfiguracja dla więcej niż 3 lub 4 elementów i (b) wykonuje obliczenia przy użyciu zestawu?: Co można zrobić za pomocą indeksowania (nie przy normalnym indeksowaniu semantyki wskaźnika C , ale mimo to indeksowanie). Chciałbym zobaczyć bardzo ograniczony typ „tablicy referencyjnej”, który faktycznie może to zrobić. To znaczy tablica odniesień nie byłaby traktowana jako ogólna tablica rzeczy, które są referencjami, ale raczej byłaby nową „tablicą referencji” zrobić za pomocą szablonów).

to prawdopodobnie zadziała, jeśli nie masz nic przeciwko temu rodzajowi nieprzyjemności: przetwórz '* this' jako tablicę int * i zwróć referencję utworzoną z jednego: (niezalecane, ale pokazuje jak właściwa 'tablica' pracowałbym):

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

Komentarz do Twojej zmiany:

Lepszym rozwiązaniem jest std::reference_wrapper.

Szczegóły: http://www.cplusplus.com/reference/functional/reference_wrapper/

Przykład:

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

Tablica jest niejawnie konwertowana na wskaźnik, a wskaźnik do odwołania jest niedozwolony w C ++

Biorąc pod uwagę int& arr[] = {a,b,c,8};, co to jest sizeof(*arr)?

Wszędzie indziej odniesienie jest traktowane jako po prostu samo w sobie, więc sizeof(*arr)powinno po prostu być sizeof(int). Ale to spowodowałoby, że arytmetyka wskaźnika tablicy na tej tablicy byłaby nieprawidłowa (zakładając, że odwołania nie mają takich samych szerokości, to ints). Aby wyeliminować niejednoznaczność, jest to zabronione.

Ponieważ, jak wielu tutaj powiedziało, odniesienia nie są obiektami. są po prostu aliasami. To prawda, że ​​niektóre kompilatory mogą zaimplementować je jako wskaźniki, ale standard tego nie wymusza / nie określa. A ponieważ odniesienia nie są obiektami, nie możesz ich wskazać. Przechowywanie elementów w tablicy oznacza, że ​​istnieje pewien rodzaj adresu indeksu (tj. Wskazujący na elementy o określonym indeksie); i dlatego nie możesz mieć tablic odniesień, ponieważ nie możesz ich wskazać.

Zamiast tego użyj boost :: reference_wrapper lub boost :: tuple; lub po prostu wskazówki.

Uważam, że odpowiedź jest bardzo prosta i ma związek z semantycznymi regułami odwołań i sposobem obsługi tablic w C ++.

W skrócie: referencje można traktować jako struktury, które nie mają domyślnego konstruktora, więc obowiązują wszystkie te same reguły.

1) Semantycznie odwołania nie mają wartości domyślnej. Referencje można tworzyć tylko poprzez odwoływanie się do czegoś. Referencje nie mają wartości reprezentującej brak odniesienia.

2) Podczas przydzielania tablicy o rozmiarze X program tworzy kolekcję obiektów inicjalizowanych domyślnie. Ponieważ odwołanie nie ma wartości domyślnej, utworzenie takiej tablicy jest semantycznie niedozwolone.

Ta reguła dotyczy również struktur / klas, które nie mają domyślnego konstruktora. Poniższy przykład kodu nie kompiluje się:

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

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

Dzięki tej strukturze szablonu możesz podejść dość blisko. Musisz jednak zainicjować wyrażeniami, które są wskaźnikami do T, a nie T; i tak, chociaż możesz w podobny sposób łatwo utworzyć 'fake_constref_array', nie będziesz w stanie powiązać tego z wartościami r, jak to zrobiono w przykładzie 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}

Obiekt referencyjny nie ma rozmiaru. Jeśli napiszesz sizeof(referenceVariable), poda on rozmiar obiektu, do którego się odwołujesz referenceVariable, a nie samego odniesienia. Nie ma własnego rozmiaru, dlatego kompilator nie może obliczyć rozmiaru wymaganego przez tablicę.

Kiedy przechowujesz coś w tablicy, jego rozmiar musi być znany (ponieważ indeksowanie tablicy zależy od rozmiaru). Wg standardu C ++ Nie określono, czy referencja wymaga przechowywania, czy też nie, ponieważ indeksowanie tablicy referencji nie byłoby możliwe.

Wystarczy dodać do całej rozmowy. Ponieważ tablice wymagają kolejnych lokalizacji pamięci do przechowywania elementu, więc jeśli utworzymy tablicę referencji, nie ma gwarancji, że będą one znajdować się w kolejnych lokalizacjach pamięci, więc dostęp będzie problemem i dlatego nie możemy nawet zastosować wszystkich operacji matematycznych na szyk.

Rozważ tablicę wskaźników. Wskaźnik to tak naprawdę adres; więc kiedy inicjalizujesz tablicę, analogicznie mówisz komputerowi: „przydziel ten blok pamięci do przechowywania tych liczb X (które są adresami innych elementów)”. Następnie, jeśli zmienisz jeden ze wskaźników, zmieniasz tylko to, na co on wskazuje; nadal jest to adres numeryczny, który sam znajduje się w tym samym miejscu.

Odwołanie jest analogiczne do aliasu. Gdybyś miał zadeklarować tablicę odniesień, po prostu powiedziałbyś komputerowi: „przydziel tę amorficzną plamę pamięci składającą się z tych wszystkich różnych elementów rozrzuconych dookoła”.

Właściwie jest to mieszanka składni C i C ++.

Powinieneś albo używać czystych tablic C, które nie mogą być referencjami, ponieważ referencje są tylko częścią C ++. Lub pójdziesz drogą C ++ i użyjesz klasy std::vectorlub std::arraydo swoich celów.

Jeśli chodzi o część edytowaną: mimo że structjest elementem z C, definiujesz konstruktora i funkcje operatora, co czyni go C ++ class. W związku z structtym nie można kompilować w czystym C!