Pourquoi ne puis-je pas faire un vecteur de références?

Quand je fais ça:

std::vector<int> hello;

Tout fonctionne très bien. Cependant, lorsque j'en fais plutôt un vecteur de références:

std::vector<int &> hello;

J'ai des erreurs horribles comme

erreur C2528: 'pointeur': le pointeur vers la référence est illégal

Je veux mettre un tas de références à des structures dans un vecteur, afin de ne pas avoir à me mêler de pointeurs. Pourquoi le vecteur fait-il une crise de colère à ce sujet? Est-ce ma seule option pour utiliser un vecteur de pointeurs à la place?

Le type de composant des conteneurs comme les vecteurs doit être assignable . Les références ne sont pas assignables (vous ne pouvez les initialiser qu'une seule fois lorsqu'elles sont déclarées et vous ne pouvez pas les faire référencer autre chose plus tard). D'autres types non attribuables ne sont pas non plus autorisés en tant que composants de conteneurs, par exemple vector<const int>n'est pas autorisé.

oui vous pouvez, chercher std::reference_wrapper, qui imite une référence mais est assignable et peut également être "réinstallé"

De par leur nature même, les références ne peuvent être établies qu'au moment de leur création; c'est-à-dire que les deux lignes suivantes ont des effets très différents:

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

En plus, c'est illégal:

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

Cependant, lorsque vous créez un vecteur, il n'y a aucun moyen d'attribuer des valeurs à ses éléments lors de la création. Vous faites essentiellement tout un tas du dernier exemple.

Ion Todirel a déjà mentionné une réponse OUI en utilisant std::reference_wrapper. Depuis C ++ 11, nous avons un mécanisme pour récupérer l'objet std::vector et supprimer la référence en utilisant std::remove_reference. Ci-dessous est donné un exemple compilé en utilisant g++et clangavec option
-std=c++11et exécuté avec succès.

#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> marchera.

Edit: était une suggestion à utiliser std::vector< boost::ref<int> >, qui ne fonctionnera pas car vous ne pouvez pas construire par défaut un boost::ref.

C'est une faille dans le langage C ++. Vous ne pouvez pas prendre l'adresse d'une référence, car tenter de le faire entraînerait l'adresse de l'objet auquel il est fait référence, et vous ne pouvez donc jamais obtenir un pointeur vers une référence. std::vectorfonctionne avec des pointeurs vers ses éléments, de sorte que les valeurs stockées doivent pouvoir être pointées. Vous devrez utiliser des pointeurs à la place.

TL; DR

Utilisez std::reference_wrappercomme ceci:

#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

Longue réponse

Comme le suggère la norme , pour un conteneur standard Xcontenant des objets de type T, Tdoit être Erasablede X.

Erasable signifie que l'expression suivante est bien formée:

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

Aest le type d'allocateur du conteneur, mest une instance d'allocateur et pest un pointeur de type *T. Voir ici pour la Erasabledéfinition.

Par défaut, std::allocator<T>est utilisé comme allocateur de vecteur. Avec l'allocateur par défaut, l'exigence est équivalente à la validité de p->~T()(Notez qu'il Ts'agit d'un type de référence et pd'un pointeur sur une référence). Cependant, le pointeur vers une référence est illégal , d'où l'expression n'est pas bien formée.

Comme d'autres l'ont mentionné, vous finirez probablement par utiliser un vecteur de pointeurs à la place.

Cependant, vous voudrez peut-être envisager d'utiliser un ptr_vector à la place!

Comme les autres commentaires le suggèrent, vous êtes limité à utiliser des pointeurs. Mais si cela peut aider, voici une technique pour éviter de faire face directement aux pointeurs.

Vous pouvez faire quelque chose comme ceci:

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