Warum kann ich keinen Referenzvektor erstellen?

Wenn ich das mache:

std::vector<int> hello;

Alles funktioniert super. Wenn ich es jedoch stattdessen zu einem Referenzvektor mache:

std::vector<int &> hello;

Ich bekomme schreckliche Fehler wie

Fehler C2528: 'Zeiger': Zeiger auf Referenz ist unzulässig

Ich möchte eine Reihe von Verweisen auf Strukturen in einen Vektor einfügen, damit ich mich nicht in Zeiger einmischen muss. Warum löst Vektor einen Wutanfall aus? Ist meine einzige Option, stattdessen einen Zeigervektor zu verwenden?

Der Komponententyp von Containern wie Vektoren muss zuweisbar sein . Referenzen können nicht zugewiesen werden (Sie können sie nur einmal initialisieren, wenn sie deklariert sind, und Sie können sie später nicht auf etwas anderes verweisen lassen). Andere nicht zuweisbare Typen sind ebenfalls nicht als Bestandteile von Containern vector<const int>zulässig , z . B. nicht zulässig.

Ja, Sie können suchen std::reference_wrapper, dass dies eine Referenz imitiert, aber zuweisbar ist und auch "neu eingesetzt" werden kann.

Referenzen können naturgemäß nur zum Zeitpunkt ihrer Erstellung festgelegt werden. dh die folgenden zwei Zeilen haben sehr unterschiedliche Auswirkungen:

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

Weiter ist das illegal:

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

Wenn Sie jedoch einen Vektor erstellen, können Sie seinen Elementen bei der Erstellung keine Werte zuweisen. Sie machen im Wesentlichen nur eine ganze Reihe des letzten Beispiels.

Ion Todirel erwähnte bereits eine Antwort JA mit std::reference_wrapper. Seit C ++ 11 haben wir einen Mechanismus zum Abrufen von Objekten aus std::vector und Entfernen der Referenz mithilfe von std::remove_reference. Im Folgenden finden Sie ein Beispiel, das mit g++und clangmit Option kompiliert
-std=c++11und erfolgreich ausgeführt wurde.

#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> wird funktionieren.

Bearbeiten: war ein zu verwendender Vorschlag std::vector< boost::ref<int> >, der nicht funktioniert, da Sie a nicht standardmäßig erstellen können boost::ref.

Es ist ein Fehler in der C ++ - Sprache. Sie können die Adresse einer Referenz nicht übernehmen, da dies dazu führen würde, dass auf die Adresse des Objekts verwiesen wird, und Sie daher niemals einen Zeiger auf eine Referenz erhalten können. std::vectorarbeitet mit Zeigern auf seine Elemente, daher muss auf die gespeicherten Werte verwiesen werden können. Sie müssen stattdessen Zeiger verwenden.

TL; DR

Verwenden Sie std::reference_wrapperwie folgt:

#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

Lange Antwort

Wie Standard schlägt vor , für einen Standard - Container, XObjekte des Typs enthalten T, Tmüssen Erasableaus X.

Erasable bedeutet, dass der folgende Ausdruck gut geformt ist:

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

A ist der Allokatortyp des Containers. m ist eine Allokatorinstanz und pein Zeiger vom Typ *T. Siehe hier für die ErasableDefinition.

Standardmäßig std::allocator<T>wird als Vektor-Allokator verwendet. Mit dem Standardzuweiser entspricht die Anforderung der Gültigkeit von p->~T()(Beachten Sie, dass dies Tein Referenztyp und pein Zeiger auf eine Referenz ist). Jedoch, Zeiger auf eine Referenz ist jedoch unzulässig , daher ist der Ausdruck nicht gut geformt.

Wie andere bereits erwähnt haben, werden Sie wahrscheinlich stattdessen einen Zeigervektor verwenden.

Möglicherweise möchten Sie jedoch stattdessen einen ptr_vector verwenden!

Wie aus den anderen Kommentaren hervorgeht, können Sie nur Zeiger verwenden. Aber wenn es hilft, ist hier eine Technik, um zu vermeiden, direkt mit Zeigern zu konfrontieren.

Sie können Folgendes tun:

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