Warum sind Arrays von Referenzen illegal?

Der folgende Code wird nicht kompiliert.

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

Was sagt der C ++ - Standard dazu?

Ich weiß, ich könnte eine Klasse deklarieren, die eine Referenz enthält, und dann ein Array dieser Klasse erstellen, wie unten gezeigt. Aber ich möchte wirklich wissen, warum der obige Code nicht kompiliert wird.

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

Es ist möglich, ein Array von Referenzen zu simulieren, struct cintrefanstatt es const int &zu simulieren.

Bei der Beantwortung Ihrer Frage zum Standard kann ich den C ++ - Standard §8.3.2 / 4 zitieren :

Es dürfen keine Hinweise auf Referenzen, werden keine Anordnungen von Referenzen und keine Hinweise auf Referenzen.

Referenzen sind keine Objekte. Sie haben keinen eigenen Speicher, sie verweisen nur auf vorhandene Objekte. Aus diesem Grund ist es nicht sinnvoll, Referenzarrays zu haben.

Wenn Sie ein leichtes Objekt möchten, das auf ein anderes Objekt verweist, können Sie einen Zeiger verwenden. Sie können ein structmit einem Referenzelement nur als Objekte in Arrays verwenden, wenn Sie für alle Referenzelemente für alle structInstanzen eine explizite Initialisierung bereitstellen . Referenzen können nicht standardmäßig initialisiert werden.

Bearbeiten: Wie jia3ep bemerkt, gibt es im Standardabschnitt zu Deklarationen ein explizites Verbot von Arrays von Referenzen.

Dies ist eine interessante Diskussion. Es ist klar, dass Arrays von Refs absolut illegal sind, aber meiner Meinung nach ist der Grund dafür nicht so einfach zu sagen: "Sie sind keine Objekte" oder "Sie haben keine Größe". Ich möchte darauf hinweisen, dass Arrays selbst in C / C ++ keine vollwertigen Objekte sind. Wenn Sie dem widersprechen, versuchen Sie, einige STL-Vorlagenklassen mithilfe eines Arrays als Vorlagenparameter 'class' zu instanziieren, und sehen Sie, was passiert. Sie können sie nicht zurückgeben, zuweisen oder als Parameter übergeben. (Ein Array-Parameter wird als Zeiger behandelt). Es ist jedoch legal, Arrays von Arrays zu erstellen. Referenzen haben eine Größe, die der Compiler berechnen kann und muss - Sie können eine Referenz nicht sizeof (), aber Sie können eine Struktur erstellen, die nur Referenzen enthält. Die Größe reicht aus, um alle Zeiger zu enthalten, die die Referenzen implementieren. Sie können'

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

Tatsächlich können Sie diese Zeile zur Strukturdefinition hinzufügen

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

... und jetzt habe ich etwas, das VIEL wie eine Reihe von Refs aussieht:

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

Dies ist kein echtes Array, sondern eine Operatorüberladung. Es werden keine Dinge ausgeführt, die Arrays normalerweise tun, wie z. B. sizeof (arr) / sizeof (arr [0]). Aber es macht genau das, was ich von einer Reihe von Referenzen möchte, mit vollkommen legalem C ++. Außer (a) es ist mühsam, mehr als 3 oder 4 Elemente einzurichten, und (b) es führt eine Berechnung mit einer Reihe von ?: Dies kann mithilfe der Indizierung erfolgen (nicht mit der normalen C-Zeiger-Berechnungssemantik-Indizierung) , aber trotzdem indizieren). Ich würde gerne einen sehr begrenzten 'Array of Reference'-Typ sehen, der dies tatsächlich kann. Das heißt, ein Array von Referenzen würde nicht als allgemeines Array von Dingen behandelt, die Referenzen sind, sondern es wäre ein neues 'Array von Referenzen'. mit Vorlagen machen).

Dies würde wahrscheinlich funktionieren, wenn Ihnen diese Art von Bösartigkeit nichts ausmacht: Neufassung von '* this' als Array von int * 's und Rückgabe einer Referenz aus einem: (nicht empfohlen, aber es zeigt, wie das richtige' Array ' würde funktionieren):

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

Kommentar zu Ihrer Bearbeitung:

Bessere Lösung ist std::reference_wrapper.

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

Beispiel:

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

Ein Array kann implizit in einen Zeiger konvertiert werden, und der Verweis auf eine Referenz ist in C ++ unzulässig

Gegeben int& arr[] = {a,b,c,8};, was ist sizeof(*arr)?

Überall sonst wird eine Referenz einfach als das Ding selbst behandelt, sizeof(*arr)sollte es also einfach sein sizeof(int). Dies würde jedoch dazu führen, dass die Array-Zeiger-Arithmetik für dieses Array falsch ist (vorausgesetzt, dass Referenzen nicht die gleiche Breite haben, ist ints). Um die Mehrdeutigkeit zu beseitigen, ist es verboten.

Denn wie viele hier gesagt haben, sind Referenzen keine Objekte. Sie sind einfach Aliase. Einige Compiler implementieren sie möglicherweise als Zeiger, aber der Standard erzwingt / spezifiziert dies nicht. Und da Referenzen keine Objekte sind, können Sie nicht darauf verweisen. Das Speichern von Elementen in einem Array bedeutet, dass es eine Art Indexadresse gibt (dh auf Elemente an einem bestimmten Index zeigen). und deshalb können Sie keine Arrays von Referenzen haben, weil Sie nicht auf sie verweisen können.

Verwenden Sie stattdessen boost :: reference_wrapper oder boost :: tuple. oder nur Zeiger.

Ich glaube, die Antwort ist sehr einfach und hat mit semantischen Referenzregeln und dem Umgang mit Arrays in C ++ zu tun.

Kurz gesagt: Referenzen können als Strukturen betrachtet werden, die keinen Standardkonstruktor haben, daher gelten dieselben Regeln.

1) Referenzen haben semantisch keinen Standardwert. Referenzen können nur durch Referenzieren erstellt werden. Referenzen haben keinen Wert, der das Fehlen einer Referenz darstellt.

2) Beim Zuweisen eines Arrays der Größe X erstellt das Programm eine Sammlung von standardmäßig initialisierten Objekten. Da die Referenz keinen Standardwert hat, ist das Erstellen eines solchen Arrays semantisch unzulässig.

Diese Regel gilt auch für Strukturen / Klassen, die keinen Standardkonstruktor haben. Das folgende Codebeispiel wird nicht kompiliert:

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

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

Mit dieser Vorlagenstruktur können Sie ziemlich nahe kommen. Sie müssen jedoch mit Ausdrücken initialisieren, die Zeiger auf T und nicht auf T sind. Obwohl Sie auf einfache Weise ein 'fake_constref_array' erstellen können, können Sie dies nicht wie im Beispiel des OP ('8') an rvalues ​​binden.

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

Ein Referenzobjekt hat keine Größe. Wenn Sie schreiben sizeof(referenceVariable), erhalten Sie die Größe des Objekts, auf das verwiesen wird referenceVariable, nicht die der Referenz selbst. Es hat keine eigene Größe, weshalb der Compiler nicht berechnen kann, wie viel Größe das Array benötigen würde.

Wenn Sie etwas in einem Array speichern, muss dessen Größe bekannt sein (da die Array-Indizierung von der Größe abhängt). Gemäß dem C ++ - Standard ist nicht angegeben, ob eine Referenz gespeichert werden muss oder nicht, sodass eine Indizierung eines Array von Referenzen nicht möglich wäre.

Nur um das ganze Gespräch zu ergänzen. Da für Arrays aufeinanderfolgende Speicherorte zum Speichern des Elements erforderlich sind, kann beim Erstellen eines Arrays von Referenzen nicht garantiert werden, dass sie sich an aufeinanderfolgenden Speicherorten befinden, sodass der Zugriff ein Problem darstellt und wir daher nicht einmal alle mathematischen Operationen anwenden können Array.

Betrachten Sie ein Array von Zeigern. Ein Zeiger ist wirklich eine Adresse; Wenn Sie also das Array initialisieren, sagen Sie dem Computer analog: "Weisen Sie diesen Speicherblock zu, um diese X-Nummern (die Adressen anderer Elemente sind) zu speichern." Wenn Sie dann einen der Zeiger ändern, ändern Sie nur das, worauf er zeigt. es ist immer noch eine numerische Adresse, die selbst an derselben Stelle sitzt.

Eine Referenz ist analog zu einem Alias. Wenn Sie eine Reihe von Referenzen deklarieren würden, würden Sie dem Computer im Grunde sagen: "Ordnen Sie diesen amorphen Speicherklumpen zu, der aus all diesen verschiedenen verstreuten Elementen besteht."

Eigentlich ist dies eine Mischung aus C- und C ++ - Syntax.

Sie sollten entweder reine C-Arrays verwenden, die keine Referenzen enthalten können, da Referenzen nur Teil von C ++ sind. Oder Sie gehen den C ++ - Weg und verwenden das std::vectoroderstd::array Klasse für Ihren Zweck.

Was den bearbeiteten Teil betrifft: Obwohl das structein Element aus C ist, definieren Sie einen Konstruktor und Operatorfunktionen, die es zu einem C ++ machen class. Folglich structwürden Sie nicht in reinem C kompilieren!