Neden referans vektörü yapamıyorum?

Bunu yaptığımda:

std::vector<int> hello;

Her şey harika çalışıyor. Ancak, bunun yerine bir referans vektörü yaptığınızda:

std::vector<int &> hello;

Gibi korkunç hatalar alıyorum

hata C2528: 'işaretçi': referans gösterici geçersiz

Ben işaretler ile karıştırmak zorunda kalmamak için, bir grup referansları bir vektör içine koymak istiyorum. Vektör neden bu konuda öfke nöbeti atıyor? Bunun yerine işaretçi vektörü kullanmak için tek seçeneğim var mı?

Vektörler gibi kapların bileşen türü atanabilir olmalıdır . Referanslar atanamaz (yalnızca bir kez bildirildiklerinde başlatabilirsiniz ve daha sonra başka bir şeye referans veremezsiniz). Kapların bileşenleri olarak diğer atanamayan türlere de izin verilmez, örn vector<const int>.

evet, std::reference_wrapperbir referansı taklit edebilir, ancak atanabilir ve ayrıca "yeniden yerleştirilebilir"

Doğası gereği, referanslar ancak oluşturuldukları anda ayarlanabilir; yani, aşağıdaki iki satırın çok farklı etkileri vardır:

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

Dahası, bu yasadışı:

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

Ancak, bir vektör oluşturduğunuzda, oluşturma sırasında öğelerine değer atamanın bir yolu yoktur. Aslında son örnekten bir sürü yapıyorsunuz.

Ion Todirel zaten EVET kullanarak bir cevaptan bahsetti std::reference_wrapper. C ++ 11'den beri nesneyi std::vector kullanarak nesneyi almak ve referansı kaldırmak için bir mekanizmaya sahibiz std::remove_reference. Aşağıda g++ve clangseçeneği kullanılarak derlenen
-std=c++11ve başarıyla yürütülen bir örnek verilmiştir .

#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> çalışacak.

Edit:std::vector< boost::ref<int> > varsayılan bir yapı oluşturamadığınız için çalışmayacak bir öneriydi boost::ref.

C ++ dilinde bir kusur. Bir başvurunun adresini alamazsınız, çünkü bunu yapmaya çalışmak nesnenin adresinin başvurulmasına neden olur ve böylece hiçbir zaman bir referansa işaretçi alamazsınız. std::vectorelemanlarına işaretçilerle çalışır, bu nedenle saklanan değerlerin işaretlenmesi gerekir. Bunun yerine işaretçiler kullanmanız gerekir.

TP; DR

Bunun std::reference_wrappergibi kullanın :

#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

Uzun cevap

Olarak standart göstermektedir , standart bir kap için Xtür nesneler içeren T, Tolmalıdır Erasableden X.

Erasable aşağıdaki ifadenin iyi oluşturulduğu anlamına gelir:

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

Akabın ayırıcı tipidir, mayırıcı örneğidir ve ptürün bir göstergesidir *T. Tanım için buraya bakın Erasable.

Varsayılan olarak, std::allocator<T>vektörün ayırıcısı olarak kullanılır. Varsayılan ayırıcı ile gereksinim, p->~T()( Tbir referans tipidir ve pbir referansın göstergesidir) geçerliliğine eşittir . Bununla birlikte, bir referansa işaret etmek yasa dışıdır , dolayısıyla ifade iyi biçimlendirilmemiştir.

Diğerlerinin de belirttiği gibi, bunun yerine muhtemelen bir işaretçi vektörü kullanacaksınız.

Ancak, bunun yerine bir ptr_vector kullanmayı düşünebilirsiniz !

Diğer yorumların önerdiği gibi, işaretçiler kullanmakla sınırlısınız. Ancak yardımcı olursa, doğrudan işaretçilerle yüzleşmekten kaçınmak için bir teknik var.

Aşağıdaki gibi bir şey yapabilirsiniz:

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