Question

我敢肯定这很简单，但是我对智能指针还很陌生，我找不到答案。

场景非常简单：我有一个类A，它为某个对象X持有一个shared_ptr：

class A{
    shared_ptr<const X> _asX;
}

现在，在一系列函数调用之后，我正在创建一个类型为B的新对象，该对象也包含此X。

class B {
private:
    shared_ptr<const X> _bsX;
public:
    B(): _bsX(nullptr) // - maybe this is problematic {}
    foo(shared_ptr<const X>& x)
    {
        _bsX = x;
        // The line above gives me undefined behavior, 
        // and when I run valgrind I get "Conditional jump or move
        // depends on uninitialized value(s)",
        // telling me this is not the correct way to do things. 
    }

请注意，这是foo真正设置_bsX而不是构造函数的值。

因此，如上所述-根据编译器的不同，我会遇到分段错误-这通常意味着某些值未初始化，后来被valgrind确认。

那我该怎么办-我曾尝试使用'reset'等。但是我很困惑，我正在寻求您的帮助。可能是const吗？还是通过引用传递？或“ =”运算符。

当我们在使用它时-我应该将X及其包装器（shared_ptr）传递给foo，还是应该传递原始指针，然后使其共享？如果是这样，请您举个例子。我也尝试过，但出现错误。

Answer 1

好的，我发现了问题，它与智能指针完全无关，但是由于我是新手，所以我认为可能是这样。我将这个答案留作以后参考。这就是我所做的（简化）：

class A{

private:

    shared_ptr<const int> _num;

public:
    A()
    {
        _num = make_shared<const int>(5);
    }

    const shared_ptr<const int>& getNum() const {return _num; }

    void printNum()
    {
        cout << *_num.get() << endl;
    }
};

class B
{


public:

    struct C{
        C() : _num(nullptr){}
        void boo(shared_ptr<const int> & num) { _num = num;}
        shared_ptr<const int> _num;
    };

    B() {}

    void foo(shared_ptr<const int>& num)
    {
        cs.reserve(2);
        for (uint32_t i = 0; i < 2 ; ++i) {

            cs.push_back(C()); // This was missing.
            cs[i].boo(num);
        }
    }

    void printCNum()
    {
        for (C c : cs) {
            cout << *c._num.get() << endl;
        }
    }

private:

    vector<C> cs;
};


int main()
{
    A a{};
    shared_ptr<const int> xx = a.getNum();

    B b{};
    b.foo(xx);

    a.printNum();
    b.printCNum();

}

对不起，我以为，当您保留对象的向量（不是指针/引用）时，它也会调用其构造函数。事实并非如此。具体来说，我增加了向量的容量，但没有增加其大小。

处理shared_ptr

1 个答案: