Tại sao tôi không thể tạo một vectơ tài liệu tham khảo?

Khi tôi làm điều này:

std::vector<int> hello;

Mọi thứ hoạt động tuyệt vời. Tuy nhiên, khi tôi biến nó thành một vectơ tham chiếu thay thế:

std::vector<int &> hello;

Tôi nhận được những lỗi khủng khiếp như

lỗi C2528: 'con trỏ': con trỏ để tham chiếu là bất hợp pháp

Tôi muốn đặt một loạt các tham chiếu đến các cấu trúc vào một vectơ, để tôi không phải can thiệp với các con trỏ. Tại sao vector ném một cơn giận dữ về điều này? Là lựa chọn duy nhất của tôi để sử dụng một vectơ con trỏ thay thế?

Loại thành phần của các thùng chứa như vectơ phải được gán . Tài liệu tham khảo không được gán (bạn chỉ có thể khởi tạo chúng một lần khi chúng được khai báo và bạn không thể làm cho chúng tham chiếu cái gì khác sau này). Các loại không thể gán khác cũng không được phép là thành phần của container, ví dụ như vector<const int>không được phép.

vâng, bạn có thể, tìm kiếm std::reference_wrapper, bắt chước một tài liệu tham khảo nhưng có thể gán được và cũng có thể được "nối lại"

Theo bản chất của chúng, các tài liệu tham khảo chỉ có thể được đặt tại thời điểm chúng được tạo; tức là hai dòng sau có tác dụng rất khác nhau:

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

Hơn nữa, điều này là bất hợp pháp:

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

Tuy nhiên, khi bạn tạo một vectơ, không có cách nào để gán giá trị cho các mục của nó khi tạo. Bạn thực chất chỉ là tạo ra một loạt các ví dụ cuối cùng.

Ion Todirel đã đề cập đến một câu trả lời CÓ bằng cách sử dụng std::reference_wrapper. Vì C ++ 11, chúng tôi có một cơ chế để lấy đối tượng từ std::vector và xóa tham chiếu bằng cách sử dụng std::remove_reference. Dưới đây được đưa ra một ví dụ được biên dịch bằng cách sử dụng g++và clangvới tùy chọn
-std=c++11và được thực hiện thành công.

#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> sẽ làm việc.

Chỉnh sửa: là một đề xuất để sử dụng std::vector< boost::ref<int> >, sẽ không hoạt động vì bạn không thể xây dựng mặc định a boost::ref.

Đó là một lỗ hổng trong ngôn ngữ C ++. Bạn không thể lấy địa chỉ của một tham chiếu, vì cố gắng làm như vậy sẽ dẫn đến địa chỉ của đối tượng được tham chiếu, và do đó bạn không bao giờ có thể đưa con trỏ đến tham chiếu. std::vectorhoạt động với các con trỏ tới các phần tử của nó, vì vậy các giá trị được lưu trữ cần phải có thể được trỏ đến. Bạn sẽ phải sử dụng con trỏ thay thế.

TL; DR

Sử dụng std::reference_wrappernhư thế này:

#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

Câu trả lời dài

Như tiêu chuẩn gợi ý , đối với một thùng chứa tiêu chuẩn Xchứa các đối tượng loại T, Tphải Erasabletừ X.

Erasable có nghĩa là biểu thức sau đây được hình thành tốt:

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

Alà loại cấp phát của trình chứa, mlà thể hiện của cấp phát và plà một con trỏ của loại *T. Xem ở đây để Erasableđịnh nghĩa.

Theo mặc định, std::allocator<T>được sử dụng như là cấp phát của vector. Với bộ cấp phát mặc định, yêu cầu tương đương với tính hợp lệ của p->~T()(Lưu ý đây Tlà loại tham chiếu và plà con trỏ tới tham chiếu). Tuy nhiên, con trỏ đến một tham chiếu là bất hợp pháp , do đó biểu thức không được hình thành tốt.

Như những người khác đã đề cập, có lẽ cuối cùng bạn sẽ sử dụng một vectơ con trỏ.

Tuy nhiên, thay vào đó , bạn có thể muốn xem xét sử dụng ptr_vector !

Như các ý kiến ​​khác cho thấy, bạn bị giới hạn trong việc sử dụng con trỏ. Nhưng nếu nó giúp, đây là một kỹ thuật để tránh đối mặt trực tiếp với con trỏ.

Bạn có thể làm một cái gì đó như sau:

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