Perché le matrici di riferimenti sono illegali?

Il seguente codice non viene compilato.

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

Cosa dice lo standard C ++ a riguardo?

So che potrei dichiarare una classe che contiene un riferimento, quindi creare un array di quella classe, come mostrato di seguito. Ma voglio davvero sapere perché il codice sopra non si compila.

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

È possibile utilizzare struct cintrefinvece di const int &simulare una matrice di riferimenti.

Rispondendo alla tua domanda sullo standard posso citare lo standard C ++ §8.3.2 / 4 :

Non devono esserci riferimenti a riferimenti, matrici di riferimenti e puntatori a riferimenti.

I riferimenti non sono oggetti. Non hanno una memoria propria, fanno semplicemente riferimento a oggetti esistenti. Per questo motivo non ha senso disporre di matrici di riferimenti.

Se si desidera un oggetto leggero che fa riferimento a un altro oggetto, è possibile utilizzare un puntatore. Sarai in grado di utilizzare a structcon un membro di riferimento come oggetti negli array se fornisci l'inizializzazione esplicita per tutti i membri di riferimento per tutte le structistanze. I riferimenti non possono essere disattivati ​​per impostazione predefinita.

Modifica: Come osserva jia3ep, nella sezione standard sulle dichiarazioni esiste un divieto esplicito sugli array di riferimenti.

Questa è una discussione interessante Chiaramente le matrici di ref sono del tutto illegali, ma IMHO il motivo per cui non è così semplice come dire "non sono oggetti" o "non hanno dimensioni". Vorrei sottolineare che gli array stessi non sono oggetti a tutti gli effetti in C / C ++ - se ti opponi a questo, prova a creare un'istanza di alcune classi di modelli stl usando un array come parametro di modello 'class' e vedi cosa succede. Non puoi restituirli, assegnarli, passarli come parametri. (un parametro di array viene trattato come un puntatore). Ma è legale creare array di array. I riferimenti hanno una dimensione che il compilatore può e deve calcolare - non puoi sizeof () un riferimento, ma puoi creare una struttura contenente nient'altro che riferimenti. Avrà una dimensione sufficiente per contenere tutti i puntatori che implementano i riferimenti. Puoi'

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

In effetti è possibile aggiungere questa linea alla definizione della struttura

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

... e ora ho qualcosa che sembra MOLTO come una serie di ref:

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

Ora, questo non è un array reale, è un sovraccarico dell'operatore; non farà cose che le matrici normalmente fanno come sizeof (arr) / sizeof (arr [0]), per esempio. Ma fa esattamente quello che voglio fare una serie di riferimenti, con C ++ perfettamente legale. Tranne (a) è una seccatura da impostare per più di 3 o 4 elementi, e (b) sta facendo un calcolo usando un gruppo di?: Che potrebbe essere fatto usando l'indicizzazione (non con la normale indicizzazione C-pointer-calcolo-semantica , ma indicizzando comunque). Mi piacerebbe vedere un tipo 'array di riferimento' molto limitato che può effettivamente farlo. Vale a dire una matrice di riferimenti non verrebbe trattata come una matrice generale di cose che sono riferimenti, ma piuttosto sarebbe una nuova "matrice di riferimento" fare con i modelli).

questo probabilmente funzionerebbe, se non ti dispiace questo tipo di cattiva: rifusione '* this' come un array di int * 'e restituisce un riferimento fatto da uno: (non raccomandato, ma mostra come il giusto' array ' funzionerebbe):

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

Commenta la tua modifica:

La soluzione migliore è std::reference_wrapper .

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

Esempio:

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

Un array è implicitamente convertibile in un puntatore e il puntatore a riferimento è illegale in C ++

Dato int& arr[] = {a,b,c,8};, che cos'è sizeof(*arr)?

Ovunque altro, un riferimento viene trattato come semplicemente la cosa stessa, quindi sizeof(*arr)dovrebbe essere semplicemente sizeof(int). Ma ciò renderebbe errata l'aritmetica del puntatore di array su questo array (supponendo che i riferimenti non abbiano le stesse larghezze in pollici). Per eliminare l'ambiguità, è vietato.

Perché come molti hanno già detto qui, i riferimenti non sono oggetti. sono semplicemente alias. È vero che alcuni compilatori potrebbero implementarli come puntatori, ma lo standard non impone / specifica ciò. E poiché i riferimenti non sono oggetti, non puoi indicarli. Memorizzare gli elementi in un array significa che esiste un qualche tipo di indirizzo di indice (cioè, che punta a elementi in un certo indice); ed è per questo che non puoi avere matrici di riferimenti, perché non puoi indicarle.

Usa boost :: reference_wrapper o boost :: tuple invece; o solo puntatori.

Credo che la risposta sia molto semplice e abbia a che fare con le regole di riferimento semantiche e il modo in cui gli array vengono gestiti in C ++.

In breve: i riferimenti possono essere pensati come strutture che non hanno un costruttore predefinito, quindi si applicano tutte le stesse regole.

1) Semanticamente, i riferimenti non hanno un valore predefinito. I riferimenti possono essere creati solo facendo riferimento a qualcosa. I riferimenti non hanno un valore per rappresentare l'assenza di un riferimento.

2) Quando si alloca un array di dimensioni X, il programma crea una raccolta di oggetti inizializzati di default. Poiché il riferimento non ha un valore predefinito, la creazione di un tale array è semanticamente illegale.

Questa regola si applica anche alle strutture / classi che non hanno un costruttore predefinito. Il seguente esempio di codice non viene compilato:

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

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

Puoi avvicinarti abbastanza con questa struttura del modello. Tuttavia, è necessario inizializzare con espressioni che sono puntatori a T, anziché a T; e così, anche se puoi facilmente creare un 'fake_constref_array' allo stesso modo, non sarai in grado di legarlo a valori come nell'esempio del PO ('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}

Un oggetto di riferimento non ha dimensioni. Se scrivi sizeof(referenceVariable), ti darà la dimensione dell'oggetto a cui fa riferimento referenceVariable, non quella del riferimento stesso. Non ha dimensioni proprie, motivo per cui il compilatore non è in grado di calcolare la dimensione richiesta dall'array.

Quando si memorizza qualcosa in un array, è necessario conoscerne le dimensioni (poiché l'indicizzazione dell'array si basa sulla dimensione). Secondo lo standard C ++ Non è specificato se un riferimento debba essere archiviato o meno, pertanto non sarebbe possibile indicizzare una matrice di riferimenti.

Solo per aggiungere a tutta la conversazione. Poiché le matrici richiedono posizioni di memoria consecutive per memorizzare l'elemento, quindi se creiamo una matrice di riferimenti, non è garantito che si trovino in una posizione di memoria consecutiva, quindi l'accesso sarà un problema e quindi non possiamo nemmeno applicare tutte le operazioni matematiche su Vettore.

Prendi in considerazione una serie di puntatori. Un puntatore è davvero un indirizzo; quindi quando inizializzi l'array, stai analogamente dicendo al computer "alloca questo blocco di memoria per contenere questi numeri X (che sono indirizzi di altri elementi)". Quindi se cambi uno dei puntatori, stai semplicemente cambiando ciò a cui punta; è ancora un indirizzo numerico che si trova nello stesso punto.

Un riferimento è analogo a un alias. Se dovessi dichiarare una serie di riferimenti, in pratica diresti al computer "allocare questa massa amorfa di memoria costituita da tutti questi diversi elementi sparsi".

In realtà, questa è una miscela di sintassi C e C ++.

Si dovrebbe o utilizzare le matrici C puri, che non possono essere di riferimenti, in quanto riferimento sono parte di C ++ solo. Oppure vai in C ++ e usa il tasto std::vectorostd::array classe per il tuo scopo.

Per quanto riguarda la parte modificata: anche se structè un elemento di C, si definiscono funzioni di costruzione e di operatore, che lo rendono un C ++ class. Di conseguenza, structnon verrai compilato in C puro!