เหตุใดฉันจึงไม่สามารถสร้างเวกเตอร์ของการอ้างอิงได้

เมื่อฉันทำสิ่งนี้:

std::vector<int> hello;

ทุกอย่างใช้งานได้ดี อย่างไรก็ตามเมื่อฉันทำให้เป็นเวกเตอร์ของการอ้างอิงแทน:

std::vector<int &> hello;

ฉันได้รับข้อผิดพลาดที่น่ากลัวเช่น

ข้อผิดพลาด C2528: 'ตัวชี้': ตัวชี้ไปยังการอ้างอิงนั้นผิดกฎหมาย

ฉันต้องการใส่การอ้างอิงจำนวนมากเพื่อวางโครงสร้างในเวกเตอร์เพื่อที่ฉันจะได้ไม่ต้องยุ่งกับพอยน์เตอร์ ทำไมเวกเตอร์ถึงโกรธเคืองเรื่องนี้? ตัวเลือกเดียวของฉันคือใช้เวกเตอร์พอยน์เตอร์แทนหรือไม่

ประเภทส่วนประกอบของภาชนะบรรจุเช่นเวกเตอร์จะต้องมอบหมาย การอ้างอิงไม่สามารถกำหนดได้ (คุณสามารถเริ่มต้นได้เมื่อมีการประกาศและคุณไม่สามารถอ้างอิงได้ในภายหลัง) ประเภทที่ไม่สามารถกำหนดได้อื่น ๆ ก็ไม่ได้รับอนุญาตเช่นเดียวกับส่วนประกอบของตู้คอนเทนเนอร์เช่นvector<const int>ไม่ได้รับอนุญาต

ใช่คุณสามารถค้นหาstd::reference_wrapperว่าเป็นการลอกเลียนแบบการอ้างอิง แต่สามารถกำหนดได้และยังสามารถ "ซ้ำ"

โดยธรรมชาติแล้วการอ้างอิงสามารถตั้งค่าได้ในเวลาที่สร้างขึ้นเท่านั้น คือสองบรรทัดต่อไปนี้มีเอฟเฟกต์ที่แตกต่างกันมาก:

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

ยิ่งกว่านี้เป็นสิ่งผิดกฎหมาย:

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

อย่างไรก็ตามเมื่อคุณสร้างเวกเตอร์จะไม่มีวิธีกำหนดค่าให้กับรายการของมันที่สร้างขึ้น คุณแค่ทำตัวอย่างทั้งหมดเป็นกลุ่ม

ไอออน Todirel กล่าวถึงคำตอบที่ใช่std::reference_wrapperใช้ ตั้งแต่ C ++ 11เรามีกลไกในการเรียกวัตถุจากและลบการอ้างอิงโดยใช้std::vector std::remove_referenceด้านล่างจะได้รับตัวอย่างที่รวบรวมโดยใช้g++และclangมีตัวเลือก
-std=c++11และดำเนินการเรียบร้อยแล้ว

#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> จะทำงาน.

แก้ไข:เป็นข้อเสนอแนะในการใช้งานซึ่งจะไม่ทำงานเพราะคุณไม่สามารถเริ่มต้นสร้างstd::vector< boost::ref<int> >boost::ref

มันเป็นข้อบกพร่องในภาษา C ++ คุณไม่สามารถใช้ที่อยู่ของการอ้างอิงได้เนื่องจากพยายามทำเช่นนั้นจะส่งผลให้ที่อยู่ของวัตถุนั้นถูกอ้างถึงและทำให้คุณไม่สามารถรับตัวชี้ไปยังการอ้างอิงได้ std::vectorทำงานร่วมกับพอยน์เตอร์ขององค์ประกอบดังนั้นค่าที่ถูกจัดเก็บจะต้องสามารถชี้ไปได้ คุณจะต้องใช้พอยน์เตอร์แทน

TL; DR

ใช้std::reference_wrapperแบบนี้:

#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

คำตอบที่ยาว

ในฐานะที่เป็นมาตรฐานให้เห็นสำหรับภาชนะมาตรฐานXที่มีวัตถุประเภทT, Tต้องมีจากErasableX

Erasable หมายความว่าการแสดงออกต่อไปนี้จะเกิดขึ้นอย่างดี:

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

Aเป็นประเภทจัดสรรคอนเทนเนอร์, mอินสแตนซ์จัดสรรและเป็นตัวชี้ประเภทp *Tดูที่นี่สำหรับErasableความหมาย

โดยค่าเริ่มต้นstd::allocator<T>จะใช้เป็นตัวจัดสรรของเวกเตอร์ ด้วยตัวจัดสรรเริ่มต้นข้อกำหนดจะเทียบเท่ากับความถูกต้องของp->~T()(หมายเหตุTคือประเภทการอ้างอิงและpเป็นตัวชี้ไปยังการอ้างอิง) อย่างไรก็ตามตัวชี้ไปยังการอ้างอิงนั้นผิดกฎหมายดังนั้นการแสดงออกจึงไม่เกิดขึ้น

ดังที่คนอื่น ๆ พูดถึงคุณอาจจะจบลงด้วยการใช้เวกเตอร์พอยน์เตอร์แทน

อย่างไรก็ตามคุณอาจต้องการใช้ptr_vectorแทน!

ตามความเห็นอื่น ๆ ที่แนะนำคุณถูก จำกัด ให้ใช้พอยน์เตอร์ แต่ถ้ามันช่วยได้นี่เป็นเทคนิคหนึ่งในการหลีกเลี่ยงการเผชิญหน้าโดยตรงกับพอยน์เตอร์

คุณสามารถทำสิ่งต่อไปนี้:

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