C++ 将std:：vector、boost:：variant和类型与引用字段一起使用

我有以下两门课：

struct A {

    A() : state(0) { }
    A(int state_arg) 
        : state{ state_arg } { }

    int state;
};

struct B {

    B(int state_arg, const int& ref)
        : state{ state_arg }, ref{ ref } { }

    int state;
    const int& ref;
};

我假设第二个字段中的字段

ref

是对另一个位置的整数的引用，可能（但不是必需的）是类型

B

的某个实例的字段

state

现在我想对这些类型执行一些操作，实际上，我使用boost:：variant库

using my_type = boost::variant<A, B>;

但是当我使用

std:：vector

的

myu类型的

int main() {

    std::vector<my_type> vec;
    vec.push_back(A(45));
    vec.push_back(B(45, boost::get<A>(vec[0]).state));

    A& at = boost::get<A>(vec[0]);
    B& bt = boost::get<B>(vec[1]);

    if (at.state == bt.ref) {
        std::cout << "SHOULD I EXPECTED THIS ?" << std::endl;
    }
    // the code doesn't print
}

intmain（）{
std:：vec；
向量推回（A（45））；
向量push_back（B（45，boost:：get（向量[0]）.state））；
A&at=boost:：get（vec[0]）；
B&bt=boost:：get（vec[1]）；
如果（at.state==bt.ref）{
std:：cout问题是，当您向向量添加第二个元素时，它会重新分配更多内存，并将第一个对象移动到新位置，而您已经挂起了引用。简单的解决方案是提前在
std:：vector
中保留足够的内存，以防止重新分配或使用另一个不移动对象的容器。但是您的最初的解决方案有一个设计缺陷-它依赖于它所引用的对象应该比它更长寿这一事实。但您的逻辑无法保证这一点，因此它会导致您在
std:：vector
中看到的问题。如果object
b
比object
a
更长寿，则在第一个示例中可能会出现同样的问题。更好的解决方案是要使用智能指针并让
B
类型的对象持有指向
a
类型对象的共享或弱指针，取决于您想要拥有的所有权。这样，您将在
std:：vector
中拥有共享指针，并且内存重新分配不会影响您：

struct A {

    A() : state(0) { }
    A(int state_arg) 
        : state{ state_arg } { }

    int state;
};
typedef std::shared_ptr<A> APtr;

struct B {

    B(int state_arg, const APtr& ptr)
        : state{ state_arg }, aptr{ ptr } { }

    int state;
    APtr aptr;
    int ref() const { return aptr->state; }
}
typedef std::shared_ptr<B> BPtr;

using my_type = boost::variant<APtr, BPtr>;

结构A{
A（）：状态（0）{}
A（整型状态参数）
：state{state_arg}{}
int状态；
};
typedef std：：共享\u ptr APtr；
结构B{
B（内部状态参数、常数APtr和ptr）
：state{state_arg}，aptr{ptr}{}
int状态；
APtr；
int ref（）常量{return aptr->state；}
}
typedef std：：共享\u ptr BPtr；
使用my_type=boost:：variant；
第二次
后推
会导致重新分配，使向量元素中的所有现有引用无效，包括传递给
B
的构造函数的引用。
struct A {

    A() : state(0) { }
    A(int state_arg) 
        : state{ state_arg } { }

    int state;
};
typedef std::shared_ptr<A> APtr;

struct B {

    B(int state_arg, const APtr& ptr)
        : state{ state_arg }, aptr{ ptr } { }

    int state;
    APtr aptr;
    int ref() const { return aptr->state; }
}
typedef std::shared_ptr<B> BPtr;

using my_type = boost::variant<APtr, BPtr>;