为什么我不能制作一个引用向量？

Question

当我这样做时：

std::vector<int> hello;

一切正常。但是，当我将其设为引用向量时：

std::vector<int &> hello;

我得到像

这样可怕的错误

error C2528：“指针”：指向引用的指针是非法的

我想把一堆对结构的引用放到一个向量中，这样我就不必去干预指针了。为什么 vector 对此大发雷霆？我唯一的选择是使用指针向量吗？

Answer 1

vector等容器的组件类型必须是可赋值的。引用是不可赋值的（你只能在声明时初始化它们一次，以后不能让它们引用其他东西）。其他不可分配的类型也不允许作为容器的组件，例如

vector<const int>

是不允许的。

Answer 2

是的，你可以寻找

std::reference_wrapper

，它模仿了一个参考，但可以分配，也可以“重新安置”

Answer 3

就其本质而言，引用只能在创建时设置；即，以下两行具有截然不同的效果：

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.

但是，当您创建矢量时，无法在创建时为其项目分配值。你基本上只是在制作最后一个例子的一大堆。

Answer 4

TL;博士

像这样使用

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

演示

长答案

正如standard所暗示的，对于包含

X

类型对象的标准容器

T

，

T

必须是来自

Erasable

的

X

。

Erasable

表示以下表达式是合式的：

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

A

是容器的分配器类型，

m

是分配器实例，

p

是

*T

类型的指针。见here

Erasable

定义。

默认情况下，

std::allocator<T>

用作向量的分配器。对于默认分配器，要求等同于

p->~T()

的有效性（注意

T

是引用类型，而

p

是指向引用的指针）。但是，指向引用的指针是非法的，因此表达式的格式不正确。

Answer 5

Ion Todirel 已经使用 std::reference_wrapper 提到了答案

YES

。 自 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";
        }             
    }

Answer 6

这是C++语言的缺陷。您不能获取引用的地址，因为尝试这样做会导致引用对象的地址，因此您永远无法获得指向引用的指针。

std::vector

使用指向其元素的指针，因此需要能够指向存储的值。你必须改用指针。

Answer 7

boost::ptr_vector<int>

会工作。

编辑： 是使用

std::vector< boost::ref<int> >

的建议，这不会起作用，因为你不能默认构造一个

boost::ref

.

Answer 8

正如其他人所提到的，您最终可能会改用指针向量。

但是，您可能需要考虑改用 ptr_vector！

Answer 9

我在C++14《国际标准ISO/IEC 14882:2014(E) Programming Language C++》中找到了原因

[8.3.2-5.s1] 不应有对引用的引用，没有引用数组，也没有指向引用的指针。

Answer 10

没有技术原因说明您不能拥有引用向量，它只是不是 API 的一部分，大概是为了使其类似于数组。可以很容易地添加一个与引用一起工作的专业化，将它们存储为内部指针并在 API 中作为引用呈现：

vector<int&> ivref;
int i = 42;
ivref.push_back(i); // address of i is stored
ivref.front() = 43; // i is set to 43
ivref.push_back(44); // Marked deleted for rvalue references 
ivref.resize(10);    // Marked deleted for vector of references

Answer 11

正如其他评论所建议的那样，您只能使用指针。 但如果有帮助，这里有一种避免直接面对指针的技术。

您可以执行以下操作：

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