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

Quand je fais ceci:

std::vector<int> hello;

Tout fonctionne très bien. Cependant, lorsque je fais un vecteur de références à la place:

std::vector<int &> hello;

- Je obtenir horribles erreurs comme

erreur C2528: 'pointeur' : pointeur de référence est illégal

Je veux mettre un tas de références à des structures dans un vecteur, de sorte que je n'ai pas à interférer avec les pointeurs. Pourquoi est vecteur de jeter une crise de colère à ce sujet? Est ma seule option pour utiliser un vecteur de pointeurs au lieu de cela?

InformationsquelleAutor Colen | 2009-05-28
  1. 300

    Le type de composant de conteneurs tels que les vecteurs doivent être assignables. Les références ne sont pas cessibles (vous ne pouvez initialiser une fois lorsqu'ils sont déclarés, et vous ne pouvez pas faire référence à quelque chose d'autre plus tard). D'autres non-cessible types ne sont pas autorisés en tant que composants de conteneurs, par exemple vector<const int> n'est pas autorisé.

    • Vous dites que je ne peux pas avoir un vecteur de vecteurs? (Je suis sûr que je l'ai fait...)
    • Oui, un std::vector< std::vector<int> > est correct, std::vector est cessible.
    • En effet, c'est le "réel" de la raison. L'erreur à propos de T* impossible de T est U& est juste un effet secondaire de l'violé l'obligation que T doit être cessible. Si le vecteur est capable de vérifier le type de paramètre, alors il serait sans doute dire "violé exigence: T& pas assignable"
    • La vérification de la assignables concept à boost.org/doc/libs/1_39_0/doc/html/Assignable.html toutes les opérations, sauf le swap sont valable sur les références.
    • Je pense que le type de composant doit également être défaut constructible, non? Et les références ne sont pas que soit.
    • non, le type de composant n'a pas besoin d'être par défaut constructible, aussi longtemps que vous ne l'appelez pas redimensionner() ou le vecteur constructeur qui prend une taille. (Je termine ce à partir de l'essayer à l'aide de g++, pas de lecture de tout spec)
    • J'ai eu ce problème en essayant de le faire: vector<vector <int>&> La solution a été de travailler avec: vector<vector<int>*>
    • Je suppose que cela pourrait faire comme static_assert<std::is_same_v<T, std::remove_reference<T>>> ou quelque chose le long de ces lignes
    • Ce n'est plus vrai. Depuis C++11, la seule opération indépendante de l'exigence de l'élément est "Effaçable", et la référence n'est pas. Voir stackoverflow.com/questions/33144419/....

    InformationsquelleAutor newacct
  2. 106

    oui, vous pouvez regarder pour std::reference_wrapper, qui imite une référence mais est cessible et peut également être "réinstaller"

    • Est-il un moyen de se déplacer à l'appel de get() premier lorsque vous tentez d'accéder à une méthode d'une instance d'une classe dans le conteneur? E. g. reference_wrapper<MyClass> my_ref(...); my_ref.get().doStuff(); n'est pas très référence.
    • N'est-il pas implcitly moulage pour le Type lui-même par le retour de la référence?
    • Oui, mais cela nécessite un contexte qui implique de conversion est nécessaire. L'accès des membres ne le font pas, d'où la nécessité pour .get(). Ce timdiels veut, c'est operator.; avoir un regard sur les dernières propositions de discussions à ce sujet.
    InformationsquelleAutor Ion Todirel
  3. 28

    De par leur nature même, les références ne peuvent être définies à la fois qu'ils sont créés; c'est à dire, 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.

    Plus loin, ce qui est illégal:

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

    Toutefois, lorsque vous créez un vecteur, il n'existe aucun moyen pour affecter des valeurs à des éléments lors de la création. Vous êtes essentiellement faire tout un tas de de la dernier exemple.

    • "lorsque vous créez un vecteur, il n'existe aucun moyen pour affecter des valeurs à des éléments lors de la création du" je ne comprends pas ce que tu veux dire par cette déclaration. Ce sont "ses éléments lors de la création"? Je peux créer un vecteur vide. Et je peux ajouter des éléments avec .push_back(). Vous êtes simplement en pointant que les références ne sont pas par défaut constructible. Mais je peux certainement avoir des vecteurs de classes qui ne sont pas par défaut constructible.
    • L'élément ype de std::vector<T> n'est pas nécessaire d'être par défaut constructible. Vous pouvez écrire struct A { A(int); private: A(); }; vector<A> a; juste des beaux - aussi longtemps que vous n'avez pas à utiliser de telles méthodes qui nécessitent d'être par défaut constructible (comme v. resize(100); - mais au lieu de cela, vous aurez besoin de faire v. resize(100, Une(1)); )
    • Et comment voulez-vous écrire un tel push_back() dans ce cas? On utilise toujours affectation, pas de construction.
    • James Curran, Aucun défaut de construction s'y déroule. push_back juste de placement-des news dans la préaffectés tampon. Voir ici: stackoverflow.com/questions/672352/... . Notez que mon n'est que le vecteur peut gérer par défaut non constructible types. Je ne prétends pas, bien sûr, qu'il pouvait manipuler T& (il ne peut pas, bien sûr).
    InformationsquelleAutor James Curran
  4. 25

    Ion Todirel déjà mentionné une réponse OUI à l'aide de std::reference_wrapper. Depuis C++11 nous avons un mécanisme permettant de récupérer l'objet à partir std::vector et de supprimer la référence à l'aide de std::remove_reference. Ci-dessous est donné un exemple compilé à l'aide de g++ et clang avec l'option

    -std=c++11 et exécutée 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";
    }             
}
    • Je ne vois pas la valeur dans std::remove_reference<> ici. Le point de std::remove_reference<> est de vous permettre d'écrire "le type T, mais sans être une référence, si c'en est un". Donc std::remove_reference<MyClass&>::type est juste le même que l'écriture de MyClass.
    • Aucune valeur à tous que vous pouvez simplement écrire for (MyClass obj3 : vec) std::cout << obj3.getval() << "\n"; (ou for (const MyClass& obj3: vec) si vous déclarez getval() const, comme vous devriez le savoir).
    InformationsquelleAutor Steephen
  5. 14

    boost::ptr_vector<int> fonctionne.

    Edit: était une suggestion pour l'utilisation std::vector< boost::ref<int> >, qui ne fonctionnera pas parce que vous ne pouvez pas par défaut-la construction d'un boost::ref.

    • Mais vous pouvez avoir un vecteur ou un défaut non constructible types, droit? Vous avez juste à être prudent de ne pas utiliser la valeur par défaut ctor. du vecteur
    • Ou resize.
    • Attention, Stimuler le pointeur de la conteneurs de prendre la propriété exclusive de la pointees. Devis: "Quand vous en avez besoin partagé de la sémantique, cette bibliothèque n'est pas ce dont vous avez besoin."
    InformationsquelleAutor Drew Dormann
  6. 12

    C'est une faille dans le langage C++. Vous ne pouvez pas prendre l'adresse d'une référence, depuis la tentative de le faire entraînerait l'adresse de l'objet visé, et donc vous pouvez ne jamais obtenir un pointeur vers une référence. std::vector travaille avec des pointeurs de ses éléments, de sorte que les valeurs stockées doivent être en mesure d'être souligné. Vous aurez à utiliser des pointeurs au lieu.

    • Je suppose que cela pourrait être mis en œuvre à l'aide d'un void * buffer et le placement de nouvelles. Non pas que cela ferait beaucoup de sens.
    • "Une faille dans la langue" est trop fort. C'est par la conception. Je ne pense pas qu'il est nécessaire que le vecteur travaille avec des pointeurs vers des éléments. Cependant, il est nécessaire que l'élément cédé. Les références ne sont pas.
    • Vous ne pouvez pas prendre la sizeof une référence.
    • vous n'avez pas besoin d'un pointeur à une référence, vous avez la référence, si vous avez besoin de l'aide du pointeur, il suffit de garder le pointeur lui-même; il n'y a pas de problème à résoudre ici
    InformationsquelleAutor Adam Rosenfield
  7. 3

    Comme d'autres l'ont mentionné, vous aurez probablement jusqu'à la fin à l'aide d'un vecteur de pointeurs au lieu.

    Cependant, vous pouvez envisager d'utiliser un ptr_vector la place!

    • Cette réponse n'est pas réalisable, depuis un ptr_vector est censé être un espace de stockage. C'est qu'il va supprimer les pointeurs à l'enlèvement. Il n'est donc pas utilisable pour son but.
    InformationsquelleAutor Martin Cote
  8. 1

    TL; DR

    Utilisation std::reference_wrapper comme 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;
}

    Démo

    Réponse longue

    Comme norme suggère, pour un conteneur standard X contenant des objets de type T, T doit être Erasable de X.

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

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

    A est du conteneur de l'allocateur de type, m est allocateur de l'instance et p est un pointeur de type *T. Voir ici pour Erasable définition.

    Par défaut, std::allocator<T> est utilisé comme vecteur de l'allocateur. Avec la valeur par défaut de l'allocateur, l'exigence est équivalent à la durée de validité de p->~T() (Note de l' T est un type de référence et p est pointeur vers une référence). Cependant, pointeur vers une référence est illégal, d'où l'expression n'est pas bien formé.

    InformationsquelleAutor ivaigult
  9. 0

    Comme les autres commentaires le suggèrent, vous êtes confiné à l'aide de pointeurs.
    Mais si cela peut aider, voici une technique pour éviter de faire face directement avec les pointeurs.

    Vous pouvez faire quelque chose comme ce qui suit:

    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]);
}
    • reinterpret_cast n'est pas nécessaire
    • Comme les autres réponses montrent, nous ne sommes pas confinés à l'aide de pointeurs à tous.
    InformationsquelleAutor Omid