¿Por qué son ilegales las matrices de referencias?

El siguiente código no se compila.

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

¿Qué dice el estándar C ++ sobre esto?

Sé que podría declarar una clase que contiene una referencia, luego crear una matriz de esa clase, como se muestra a continuación. Pero realmente quiero saber por qué el código anterior no se 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};
}

Es posible usar en struct cintreflugar de const int &simular una matriz de referencias.

Respondiendo a su pregunta sobre el estándar, puedo citar el Estándar C ++ §8.3.2 / 4 :

No debe haber referencias a referencias, ni matrices de referencias , ni punteros a referencias.

Las referencias no son objetos. No tienen almacenamiento propio, solo hacen referencia a objetos existentes. Por esta razón, no tiene sentido tener matrices de referencias.

Si desea un objeto liviano que haga referencia a otro objeto, puede usar un puntero. Solo podrá usar a structcon un miembro de referencia como objetos en matrices si proporciona una inicialización explícita para todos los miembros de referencia para todas las structinstancias. Las referencias no se pueden inicializar por defecto.

Editar: Como señala jia3ep, en la sección estándar sobre declaraciones hay una prohibición explícita sobre las matrices de referencias.

Esta es una discusión interesante. Claramente, las matrices de referencias son completamente ilegales, pero en mi humilde opinión, la razón por la cual no es tan simple como decir 'no son objetos' o 'no tienen tamaño'. Señalaría que las matrices en sí mismas no son objetos completos en C / C ++: si se opone a eso, intente crear instancias de algunas clases de plantillas stl utilizando una matriz como parámetro de plantilla de 'clase' y vea qué sucede. No puede devolverlos, asignarlos, pasarlos como parámetros. (un parámetro de matriz se trata como un puntero). Pero es legal hacer matrices de matrices. Las referencias tienen un tamaño que el compilador puede y debe calcular: no puede sizeof () una referencia, pero puede hacer una estructura que contenga nada más que referencias. Tendrá un tamaño suficiente para contener todos los punteros que implementan las referencias. Usted puede'

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

De hecho, puede agregar esta línea a la definición de estructura

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

... y ahora tengo algo que se parece MUCHO a una serie de referencias:

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

Ahora, esto no es una matriz real, es una sobrecarga del operador; no hará cosas que las matrices normalmente hacen como sizeof (arr) / sizeof (arr [0]), por ejemplo. Pero hace exactamente lo que quiero que haga una serie de referencias, con C ++ perfectamente legal. Excepto (a) es difícil configurar más de 3 o 4 elementos, y (b) está haciendo un cálculo usando un montón de? , pero no obstante la indexación). Me gustaría ver un tipo muy limitado de "matriz de referencia" que realmente puede hacer esto. Es decir, una matriz de referencias no se trataría como una matriz general de cosas que son referencias, sino que sería una nueva 'matriz de referencia' hacer con plantillas).

Esto probablemente funcionaría, si no le importa este tipo de desagradable: reescriba '* this' como una matriz de int * 's y devuelva una referencia hecha desde uno: (no recomendado, pero muestra cómo la' matriz 'adecuada trabajaría):

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

Comenta tu edición:

La mejor solución es std::reference_wrapper.

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

Ejemplo:

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

Una matriz se puede convertir implícitamente en un puntero, y el puntero a referencia es ilegal en C ++

Dado int& arr[] = {a,b,c,8};, ¿qué es sizeof(*arr)?

En todas partes, una referencia se trata simplemente como la cosa misma, por lo sizeof(*arr)que simplemente debería serlo sizeof(int). Pero esto haría que la aritmética del puntero de matriz en esta matriz sea incorrecta (suponiendo que las referencias no sean del mismo ancho que las ints). Para eliminar la ambigüedad, está prohibido.

Porque como muchos han dicho aquí, las referencias no son objetos. son simplemente alias. Es cierto que algunos compiladores pueden implementarlos como punteros, pero el estándar no fuerza / especifica eso. Y debido a que las referencias no son objetos, no puede señalarlas. Almacenar elementos en una matriz significa que hay algún tipo de dirección de índice (es decir, apuntando a elementos en un cierto índice); y es por eso que no puede tener matrices de referencias, porque no puede señalarlas.

Use boost :: reference_wrapper, o boost :: tuple en su lugar; o simplemente punteros.

Creo que la respuesta es muy simple y tiene que ver con reglas de referencias semánticas y cómo se manejan las matrices en C ++.

En resumen: las referencias pueden considerarse estructuras que no tienen un constructor predeterminado, por lo que se aplican las mismas reglas.

1) Semánticamente, las referencias no tienen un valor predeterminado. Las referencias solo se pueden crear haciendo referencia a algo. Las referencias no tienen un valor para representar la ausencia de una referencia.

2) Al asignar una matriz de tamaño X, el programa crea una colección de objetos inicializados por defecto. Como la referencia no tiene un valor predeterminado, crear una matriz de este tipo es semánticamente ilegal.

Esta regla también se aplica a estructuras / clases que no tienen un constructor predeterminado. El siguiente ejemplo de código no se compila:

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

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

Puede acercarse bastante con esta estructura de plantilla. Sin embargo, debe inicializar con expresiones que son punteros a T, en lugar de T; y así, aunque puede hacer fácilmente un 'fake_constref_array' de manera similar, no podrá vincularlo a los valores como se hizo en el ejemplo del 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}

Un objeto de referencia no tiene tamaño. Si escribe sizeof(referenceVariable), le dará el tamaño del objeto al que hace referencia referenceVariable, no el de la referencia en sí. No tiene un tamaño propio, por lo que el compilador no puede calcular cuánto tamaño requeriría la matriz.

Cuando almacena algo en una matriz, su tamaño debe ser conocido (ya que la indexación de la matriz depende del tamaño). Según el estándar de C ++ No se especifica si una referencia requiere almacenamiento o no, por lo que no sería posible indexar una matriz de referencias.

Solo para agregar a toda la conversación. Dado que las matrices requieren ubicaciones de memoria consecutivas para almacenar el elemento, por lo tanto, si creamos una matriz de referencias, no se garantiza que estén en una ubicación de memoria consecutiva, por lo que el acceso será un problema y, por lo tanto, ni siquiera podemos aplicar todas las operaciones matemáticas en formación.

Considere una variedad de punteros. Un puntero es realmente una dirección; así que cuando inicializa la matriz, le está diciendo de manera análoga a la computadora, "asigne este bloque de memoria para contener estos números X (que son direcciones de otros elementos)". Entonces, si cambia uno de los punteros, solo está cambiando lo que apunta; sigue siendo una dirección numérica que se encuentra en el mismo lugar.

Una referencia es análoga a un alias. Si declarara una serie de referencias, básicamente le estaría diciendo a la computadora, "asigne esta gota de memoria amorfa que consiste en todos estos elementos diferentes dispersos".

En realidad, esta es una mezcla de sintaxis C y C ++.

Usted debe o bien utilizar matrices C puros, que no puede ser de referencias, ya que son parte de referencia C ++ solamente. O sigue el camino de C ++ y usa la clase std::vectoro std::arraypara su propósito.

En cuanto a la parte editada: aunque structes un elemento de C, usted define un constructor y funciones de operador, que lo convierten en C ++ class. En consecuencia, su structno compilaría en C puro!