Dlaczego nie mogę utworzyć wektora odniesień?

Kiedy to zrobię:

std::vector<int> hello;

Wszystko działa świetnie. Kiedy jednak zrobię z tego wektor odnośników:

std::vector<int &> hello;

Dostaję straszne błędy jak

błąd C2528: „wskaźnik”: wskaźnik do odwołania jest nielegalny

Chcę umieścić wiele wektorów struktur w wektorze, aby nie musiałem mieszać się ze wskaźnikami. Dlaczego wektor wywołuje w tym napad złości? Czy moją jedyną opcją jest użycie wektora wskaźników?

Typ komponentów pojemników, takich jak wektory, musi być możliwy do przypisania . Odniesień nie można przypisać (możesz je zainicjować tylko raz, gdy zostaną zadeklarowane, i nie możesz później zmuszać ich do odwoływania się do czegoś innego). Inne typy nieprzenoszalne również nie są dozwolone jako elementy kontenerów, np. vector<const int>Nie są dozwolone.

tak, możesz poszukać std::reference_wrapper, który naśladuje odniesienie, ale można go przypisać i można go również „zresetować”

Ze swej natury odniesienia można ustawiać tylko w momencie ich tworzenia; tj. następujące dwie linie mają bardzo różne efekty:

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

Ponadto jest to nielegalne:

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

Jednak podczas tworzenia wektora nie ma możliwości przypisania wartości do jego elementów podczas tworzenia. Zasadniczo robisz całą masę ostatniego przykładu.

Ion Todirel już wspomniano odpowiedź TAK użyciu std::reference_wrapper. Od wersji C ++ 11 mamy mechanizm pobierania obiektu std::vector i usuwania referencji za pomocą std::remove_reference. Poniżej podano przykład skompilowany przy użyciu g++iz clangopcją
-std=c++11i wykonany pomyślnie.

#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> będzie działać.

Edycja: była sugestią użycia std::vector< boost::ref<int> >, która nie będzie działać, ponieważ nie można domyślnie skonstruować pliku boost::ref.

Jest to usterka w języku C ++. Nie możesz pobrać adresu referencji, ponieważ próba zrobienia tego spowodowałaby adres obiektu, do którego się odnosi, a zatem nigdy nie możesz uzyskać wskaźnika do referencji. std::vectorwspółpracuje ze wskaźnikami do jego elementów, więc przechowywane wartości muszą być możliwe do wskazania. Zamiast tego będziesz musiał użyć wskaźników.

TL; DR

Użyj w std::reference_wrapperten sposób:

#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

Długa odpowiedź

Jako standard ten sugeruje , dla standardowego kontenera Xzawierającego obiekty typu T, Tmoże być Erasablez X.

Erasable oznacza, że ​​następujące wyrażenie jest dobrze uformowane:

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

Ajest typem alokatora kontenera, mjest instancją alokatora i pjest wskaźnikiem typu *T. Patrz tutaj dla Erasabledefinicji.

Domyślnie std::allocator<T>jest używany jako alokator wektora. W domyślnym alokatorze wymaganie jest równoważne z ważnością p->~T()(Uwaga: Tjest to typ odwołania i pjest wskaźnikiem do odwołania). Jednak wskaźnik do odwołania jest nielegalny , dlatego wyrażenie nie jest dobrze uformowane.

Jak już wspomnieli inni, prawdopodobnie zamiast tego użyjesz wektora wskaźników.

Możesz jednak rozważyć użycie ptr_vector !

Jak sugerują inne komentarze, ograniczasz się do używania wskaźników. Ale jeśli to pomaga, oto jedna technika, aby uniknąć bezpośredniego spojrzenia na wskaźniki.

Możesz zrobić coś takiego:

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