¿Por qué no puedo hacer un vector de referencias?

Cuando hago esto:

std::vector<int> hello;

Todo funciona muy bien. Sin embargo, cuando lo convierto en un vector de referencias en su lugar:

std::vector<int &> hello;

Recibo errores horribles como

error C2528: 'puntero': el puntero a referencia es ilegal

Quiero poner un montón de referencias a estructuras en un vector, para no tener que entrometerme con punteros. ¿Por qué el vector está haciendo un berrinche sobre esto? ¿Es mi única opción usar un vector de punteros en su lugar?

El tipo de componente de los contenedores, como los vectores, debe ser asignable . Las referencias no son asignables (solo puede inicializarlas una vez cuando se declaran, y no puede hacer que hagan referencia a otra cosa más adelante). Otros tipos no asignables tampoco están permitidos como componentes de contenedores, por ejemplo, vector<const int>no está permitido.

Sí, puede, busque std::reference_wrapper, que imita una referencia pero es asignable y también puede ser "reubicado"

Por su propia naturaleza, las referencias solo se pueden establecer en el momento en que se crean; es decir, las siguientes dos líneas tienen efectos muy diferentes:

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

Además, esto es ilegal:

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

Sin embargo, cuando crea un vector, no hay forma de asignar valores a sus elementos en la creación. Básicamente solo estás haciendo un montón del último ejemplo.

Ion Todirel ya mencionó una respuesta SÍ usando std::reference_wrapper. Desde C ++ 11 tenemos un mecanismo para recuperar objetos std::vector y eliminar la referencia mediante el uso std::remove_reference. A continuación se muestra un ejemplo compilado usando g++y clangcon la opción
-std=c++11y ejecutado con éxito.

#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> trabajará.

Editar: fue una sugerencia de uso std::vector< boost::ref<int> >, que no funcionará porque no se puede construir por defecto a boost::ref.

Es una falla en el lenguaje C ++. No puede tomar la dirección de una referencia, ya que intentar hacerlo daría lugar a la dirección del objeto al que se hace referencia y, por lo tanto, nunca puede obtener un puntero a una referencia. std::vectorfunciona con punteros a sus elementos, por lo que los valores que se almacenan deben poder señalarse. Tendrás que usar punteros en su lugar.

TL; DR

Usar std::reference_wrapperasí:

#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

Respuesta larga

Como sugiere el estándar , para un contenedor estándar que Xcontiene objetos de tipo T, Tdebe ser Erasablede X.

Erasable significa que la siguiente expresión está bien formada:

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

Aes el tipo de asignador del contenedor, mes la instancia del asignador y pes un puntero de tipo *T. Ver aquí para la Erasabledefinición.

Por defecto, std::allocator<T>se utiliza como asignador de vectores. Con el asignador predeterminado, el requisito es equivalente a la validez de p->~T()(Tenga en cuenta que Tes un tipo de referencia y papunta a una referencia). Sin embargo, el puntero a una referencia es ilegal , por lo tanto, la expresión no está bien formada.

Como otros han mencionado, probablemente terminarás usando un vector de punteros en su lugar.

Sin embargo, ¡puede considerar usar un ptr_vector en su lugar!

Como sugieren los otros comentarios, está limitado a usar punteros. Pero si ayuda, aquí hay una técnica para evitar enfrentar directamente con punteros.

Puedes hacer algo como lo siguiente:

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