Por que matrizes de referências são ilegais?

O código a seguir não compila.

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

O que o padrão C ++ diz sobre isso?

Eu sei que posso declarar uma classe que contém uma referência e criar uma matriz dessa classe, como mostrado abaixo. Mas eu realmente quero saber por que o código acima não é compilado.

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

É possível usar em struct cintrefvez de const int &simular uma matriz de referências.

Respondendo à sua pergunta sobre o padrão, posso citar o Padrão C ++ §8.3.2 / 4 :

Não deve haver referências a referências, nem matrizes de referências nem ponteiros para referências.

Referências não são objetos. Eles não têm armazenamento próprio, apenas referenciam objetos existentes. Por esse motivo, não faz sentido ter matrizes de referências.

Se você deseja um objeto leve que faça referência a outro objeto, use um ponteiro. Você só poderá usar a structcom um membro de referência como objetos em matrizes se fornecer inicialização explícita para todos os membros de referência para todas as structinstâncias. As referências não podem ser inicializadas por padrão.

Edit: Como jia3ep observa, na seção padrão sobre declarações, há uma proibição explícita de matrizes de referências.

Esta é uma discussão interessante. Claramente, matrizes de árbitros são totalmente ilegais, mas IMHO a razão pela qual não é tão simples como dizer 'eles não são objetos' ou 'eles não têm tamanho'. Eu apontaria que as próprias matrizes não são objetos completos no C / C ++ - se você se opuser a isso, tente instanciar algumas classes de modelo stl usando uma matriz como parâmetro de modelo de 'classe' e veja o que acontece. Você não pode devolvê-los, atribuí-los, passá-los como parâmetros. (um parâmetro de matriz é tratado como um ponteiro). Mas é legal fazer matrizes de matrizes. As referências têm um tamanho que o compilador pode e deve calcular - você não pode sizeof () uma referência, mas pode criar uma estrutura contendo nada além de referências. Ele terá um tamanho suficiente para conter todos os ponteiros que implementam as referências. Você pode'

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

Na verdade, você pode adicionar esta linha à definição de estrutura

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

... e agora eu tenho algo que se parece muito com uma variedade de referências:

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

Agora, isso não é uma matriz real, é uma sobrecarga de operador; ele não fará coisas que as matrizes normalmente fazem como sizeof (arr) / sizeof (arr [0]), por exemplo. Mas faz exatamente o que eu quero que uma matriz de referências faça, com C ++ perfeitamente legal. Exceto (a) é difícil configurar mais de 3 ou 4 elementos e (b) está fazendo um cálculo usando um monte de?: O que pode ser feito usando a indexação (não com a indexação normal de C-ponteiro-cálculo-semântica) , mas indexando). Eu gostaria de ver um tipo muito limitado de 'matriz de referência' que realmente pode fazer isso. Ou seja, uma matriz de referências não seria tratada como uma matriz geral de coisas que são referências, mas seria uma nova 'matriz de referência' fazer com modelos).

isso provavelmente funcionaria, se você não se importar com esse tipo de desagradável: reformule '* this' como uma matriz de int * 's e retorne uma referência feita a partir de uma: (não recomendado, mas mostra como a' matriz 'adequada trabalharia):

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

Comentário à sua edição:

Melhor solução é std::reference_wrapper .

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

Exemplo:

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

Uma matriz é implicitamente convertível em um ponteiro, e o ponteiro para referência é ilegal em C ++

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

Em qualquer outro lugar, uma referência é tratada como sendo simplesmente a coisa em si, sizeof(*arr)deveria simplesmente ser sizeof(int). Mas isso tornaria o ponteiro da matriz aritmético nessa matriz errado (supondo que as referências não tenham as mesmas larguras são ints). Para eliminar a ambiguidade, é proibido.

Porque, como muitos disseram aqui, referências não são objetos. eles são simplesmente aliases. É verdade que alguns compiladores podem implementá-los como ponteiros, mas o padrão não força / especifica isso. E como as referências não são objetos, você não pode apontar para eles. Armazenar elementos em uma matriz significa que existe algum tipo de endereço de índice (ou seja, apontar para elementos em um determinado índice); e é por isso que você não pode ter matrizes de referências, porque não pode apontar para elas.

Use boost :: reference_wrapper ou boost :: tuple; ou apenas ponteiros.

Eu acredito que a resposta é muito simples e tem a ver com regras semânticas de referências e como as matrizes são tratadas em C ++.

Resumindo: as referências podem ser consideradas estruturas que não possuem um construtor padrão; portanto, todas as mesmas regras se aplicam.

1) Semântica, as referências não têm um valor padrão. As referências só podem ser criadas fazendo referência a algo. As referências não têm um valor para representar a ausência de uma referência.

2) Ao alocar uma matriz de tamanho X, o programa cria uma coleção de objetos inicializados por padrão. Como a referência não tem um valor padrão, a criação de uma matriz é semanticamente ilegal.

Esta regra também se aplica a estruturas / classes que não possuem um construtor padrão. O seguinte exemplo de código não compila:

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

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

Você pode se aproximar bastante dessa estrutura do modelo. No entanto, você precisa inicializar com expressões que apontam para T, em vez de T; e assim, embora você possa criar facilmente um 'fake_constref_array' da mesma forma, não poderá vincular isso a rvalues, como foi feito no exemplo do 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}

Um objeto de referência não tem tamanho. Se você escrever sizeof(referenceVariable), ele fornecerá o tamanho do objeto referenciado por referenceVariable, não o da própria referência. Ele não tem tamanho próprio, e é por isso que o compilador não pode calcular quanto tamanho a matriz exigiria.

Quando você armazena algo em uma matriz, seu tamanho precisa ser conhecido (uma vez que a indexação da matriz depende do tamanho). De acordo com o padrão C ++, não é especificado se uma referência requer ou não armazenamento; como resultado, a indexação de uma matriz de referências não seria possível.

Apenas para adicionar a toda a conversa. Como as matrizes requerem locais de memória consecutivos para armazenar o item, por isso, se criarmos uma matriz de referências, não é garantido que elas estejam em local de memória consecutiva, portanto, o acesso será um problema e, portanto, não podemos aplicar todas as operações matemáticas em array.

Considere uma variedade de ponteiros. Um ponteiro é realmente um endereço; portanto, quando você inicializa a matriz, informa analogicamente ao computador "aloque esse bloco de memória para armazenar esses números X (que são endereços de outros itens)". Então, se você alterar um dos ponteiros, estará apenas mudando para o que ele aponta; ainda é um endereço numérico que está no mesmo local.

Uma referência é análoga a um alias. Se você declarasse uma série de referências, basicamente diria ao computador: "aloque essa bolha amorfa de memória que consiste em todos esses itens diferentes espalhados".

Na verdade, essa é uma mistura da sintaxe C e C ++.

Deverá quer usar matrizes C puras, que não pode ser de referências, uma vez que são parte de referência C ++ única. Ou você segue o caminho C ++ e usa o std::vectoroustd::array classe para sua finalidade.

Quanto à parte editada: Embora structseja um elemento de C, você define funções de construtor e operador, que o tornam um C ++ class. Consequentemente, o seu structnão seria compilado em C puro!