Perché non riesco a creare un vettore di riferimenti?

Quando faccio questo:

std::vector<int> hello;

Funziona tutto alla grande. Tuttavia, quando lo trasformo in un vettore di riferimenti invece:

std::vector<int &> hello;

Ottengo errori orribili come

errore C2528: 'pointer': il puntatore al riferimento è illegale

Voglio mettere un mucchio di riferimenti a strutture in un vettore, in modo da non dover intromettermi con i puntatori. Perché il vettore sta dando una scossa a questo proposito? È invece la mia unica opzione di utilizzare un vettore di puntatori?

Il tipo di componente di contenitori come i vettori deve essere assegnabile . I riferimenti non sono assegnabili (puoi inizializzarli solo una volta quando vengono dichiarati e non puoi farli fare riferimento a qualcos'altro in seguito). Anche altri tipi non assegnabili non sono ammessi come componenti dei contenitori, ad esempio vector<const int>non è consentito.

sì, puoi, cercare std::reference_wrapper, che imita un riferimento ma è assegnabile e può anche essere "ripristinato"

Per loro stessa natura, i riferimenti possono essere impostati solo nel momento in cui vengono creati; cioè, le seguenti due linee hanno effetti molto diversi:

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

Inoltre, questo è illegale:

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

Tuttavia, quando si crea un vettore, non è possibile assegnare valori ai relativi elementi al momento della creazione. In sostanza, stai solo facendo un mucchio dell'intero esempio.

Ion Todirel ha già menzionato una risposta SÌ utilizzando std::reference_wrapper. Dal C ++ 11 abbiamo un meccanismo per recuperare l'oggetto da std::vector e rimuovere il riferimento usando std::remove_reference. Di seguito viene fornito un esempio compilato utilizzando g++e clangcon opzione
-std=c++11ed eseguito correttamente.

#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> funzionerà.

Modifica: è stato un suggerimento da utilizzare std::vector< boost::ref<int> >, che non funzionerà perché non è possibile creare un predefinito a boost::ref.

È un difetto nel linguaggio C ++. Non è possibile prendere l'indirizzo di un riferimento, poiché tentare di farlo comporterebbe il riferimento all'indirizzo dell'oggetto a cui si fa riferimento e quindi non è mai possibile ottenere un puntatore a un riferimento. std::vectorfunziona con i puntatori ai suoi elementi, quindi i valori memorizzati devono poter essere puntati. Dovrai invece utilizzare i puntatori.

TL; DR

Usa std::reference_wrappercosì:

#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

Risposta lunga

Come suggerisce la norma , per un contenitore standard Xcontenente oggetti di tipo T, Tdeve provenire Erasableda X.

Erasable significa che la seguente espressione è ben formata:

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

Aè il tipo di allocatore del contenitore, mè un'istanza di allocatore ed pè un puntatore di tipo *T. Vedi qui per Erasabledefinizione.

Per impostazione predefinita, std::allocator<T>viene utilizzato come allocatore del vettore. Con l'allocatore predefinito, il requisito è equivalente alla validità di p->~T()(Notare che Tè un tipo di riferimento ed pè puntatore a un riferimento). Tuttavia, il puntatore a un riferimento è illegale , quindi l'espressione non è ben formata.

Come altri hanno già detto, probabilmente finirai per usare un vettore di puntatori.

Tuttavia, potresti prendere in considerazione l' idea di utilizzare un ptr_vector !

Come suggeriscono gli altri commenti, sei limitato all'uso dei puntatori. Ma se aiuta, ecco una tecnica per evitare di affrontare direttamente i puntatori.

Puoi fare qualcosa di simile al seguente:

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