Por que não consigo fazer um vetor de referências?

Quando eu faço isso:

std::vector<int> hello;

Tudo funciona muito bem. No entanto, quando eu faço um vetor de referências:

std::vector<int &> hello;

Eu recebo erros horríveis como

erro C2528: 'ponteiro': o ponteiro para referência é ilegal

Quero colocar um monte de referências a estruturas em um vetor, para não precisar me intrometer com ponteiros. Por que o vetor está fazendo uma birra sobre isso? Minha única opção é usar um vetor de ponteiros?

O tipo de componente de contêineres como vetores deve ser atribuível . As referências não são atribuíveis (você só pode inicializá-las uma vez quando são declaradas e não pode fazer com que elas façam referência a outra coisa posteriormente). Outros tipos não atribuíveis também não são permitidos como componentes de contêineres, por exemplo, vector<const int>não é permitido.

sim, você pode procurar std::reference_wrapperque imita uma referência, mas é atribuível e também pode ser "recolocado"

Por sua própria natureza, as referências só podem ser definidas no momento em que são criadas; ou seja, as duas linhas a seguir têm efeitos muito diferentes:

int & A = B;   // makes A an alias for B
A = C;         // assigns value of C to B.

Além disso, isso é ilegal:

int & D;       // must be set to a int variable.

No entanto, quando você cria um vetor, não há como atribuir valores a seus itens na criação. Você está essencialmente apenas criando um monte do último exemplo.

Ion Todirel já mencionou uma resposta YES usando std::reference_wrapper. Desde o C ++ 11 , temos um mecanismo para recuperar o objeto std::vector e remover a referência usando std::remove_reference. Abaixo é dado um exemplo compilado usando g++e clangcom a opção
-std=c++11e executado com sucesso.

#include <iostream>
#include <vector>
#include<functional>

class MyClass {
public:
    void func() {
        std::cout << "I am func \n";
    }

    MyClass(int y) : x(y) {}

    int getval()
    {
        return x;
    }

private: 
        int x;
};

int main() {
    std::vector<std::reference_wrapper<MyClass>> vec;

    MyClass obj1(2);
    MyClass obj2(3);

    MyClass& obj_ref1 = std::ref(obj1);
    MyClass& obj_ref2 = obj2;

    vec.push_back(obj_ref1);
    vec.push_back(obj_ref2);

    for (auto obj3 : vec)
    {
        std::remove_reference<MyClass&>::type(obj3).func();      
        std::cout << std::remove_reference<MyClass&>::type(obj3).getval() << "\n";
    }             
}

boost::ptr_vector<int> vai funcionar.

Editar: foi uma sugestão a ser usada std::vector< boost::ref<int> >, que não funcionará porque você não pode construir por padrão a boost::ref.

É uma falha na linguagem C ++. Você não pode usar o endereço de uma referência, pois a tentativa resultaria na referência ao endereço do objeto e, portanto, você nunca poderá obter um ponteiro para uma referência. std::vectortrabalha com ponteiros para seus elementos, portanto, os valores que estão sendo armazenados precisam poder ser apontados. Você precisará usar ponteiros.

TL; DR

Use std::reference_wrapperassim:

#include <functional>
#include <string>
#include <vector>
#include <iostream>

int main()
{
    std::string hello = "Hello, ";
    std::string world = "everyone!";
    typedef std::vector<std::reference_wrapper<std::string>> vec_t;
    vec_t vec = {hello, world};
    vec[1].get() = "world!";
    std::cout << hello << world << std::endl;
    return 0;
}

Demo

Resposta longa

Como o padrão sugere , para um contêiner padrão Xcontendo objetos do tipo T, Tdeve ser Erasablede X.

Erasable significa que a seguinte expressão está bem formada:

allocator_traits<A>::destroy(m, p)

Aé alocador tipo de recipiente, mé exemplo alocador e pé um ponteiro de tipo *T. Veja aqui paraErasable definição.

Por padrão, std::allocator<T>é usado como alocador de vetor. Com o alocador padrão, o requisito é equivalente à validade de p->~T()(Observe que Té um tipo de referência e pé ponteiro para uma referência). No entanto, o ponteiro para uma referência é ilegal , portanto, a expressão não está bem formada.

Como já mencionado, você provavelmente acabará usando um vetor de ponteiros.

No entanto, você pode considerar o uso de um ptr_vector !

Como os outros comentários sugerem, você está limitado a usar ponteiros. Mas se ajudar, aqui está uma técnica para evitar o enfrentamento direto de ponteiros.

Você pode fazer algo como o seguinte:

vector<int*> iarray;
int default_item = 0; // for handling out-of-range exception

int& get_item_as_ref(unsigned int idx) {
   // handling out-of-range exception
   if(idx >= iarray.size()) 
      return default_item;
   return reinterpret_cast<int&>(*iarray[idx]);
}