Question

因此，您拥有类型为x的对象X和类型为Y的对象y。 X和Y是相关的，y必须在其相关的x之前销毁。

换句话说，就像这样：

struct X { void do_something(); }
struct Y
{
    Y(X&x) : my_x(&x) {}
    void do_something() { my_x->do_something(); }
private:
    X * my_x;
};

作为一名防御性程序员，您希望使用上面my_x的智能指针。但是，据我所知，没有合适的指针。这个指针需要知道它不拥有它的原始指针，并且它不应该超过它指向的对象。

我认为在大多数情况下，这不可能在编译时显示。但是，在某些情况下，y可能证明x不恰当地超过其{{1}}。

在这种情况下，您是否可以想到创建编译时错误的方法，还是我们遇到了运行时断言？

Answer 1

这不能解决您的问题吗？它确保在Y之前始终销毁相关的X。

struct X;

struct Y
{
    Y(X& x) : my_x(&x) {}
    void do_something() { my_x->do_something(); }
private:
    X* my_x;
};

struct X
{
    X() : owned_y_(this) { }
    void do_something();
private:
    Y owned_y_;
};

Answer 2

你可以试试这个

struct X { void do_something(); }
struct Y
{
    Y(X&x) : my_x(&x) {}
    void do_something() { my_x->do_something(); }
private:
    X * my_x;
 };


struct XY_Holder{
    X x_;
    Y y_;
    XY_Holder():x_{},y_{&x_}{}
};

x_和y_对象将按顺序构造或声明并以相反的顺序销毁，因此编译器确保y_不会超过x _

编译时间生命周期检查

2 个答案: