4

boost::shared_ptr 真的让我很困扰。当然,我了解这种东西的实用性,但我希望我可以shared_ptr<A> A*. 考虑以下代码

class A
{
public:
    A() {}
    A(int x) {mX = x;}
    virtual void setX(int x) {mX = x;}
    virtual int getX() const {return mX;}
private:
    int mX;
};


class HelpfulContainer
{
public:
    //Don't worry, I'll manager the memory from here.
    void eventHorizon(A*& a)
    {
        cout << "It's too late to save it now!" << endl;
        delete a;
        a = NULL;
    }
};


int main()
{
    HelpfulContainer helpfulContainer;

    A* a1 = new A(1);
    A* a2 = new A(*a1);
    cout << "*a1 = " << *a1 << endl;
    cout << "*a2 = " << *a2 << endl;
    a2->setX(2);
    cout << "*a1 = " << *a1 << endl;
    cout << "*a2 = " << *a2 << endl;
    cout << "Demonstrated here a2 is not connected to a1." << endl;

    //hey, I wonder what this event horizon function is.
    helpfulContainer.eventHorizon(a1);

    cout << "*a1 = " << *a1 << endl;//Bad things happen when running this line.
}

创建 HelpfulContainer 的人并没有考虑其他人想要保留指向 A 对象的指针。我们不能给 HelpfulClass boost::shared_ptr 对象。但是我们可以做的一件事是使用 pimlp 习惯用法来创建一个 SharedA,它本身就是一个 A:

class SharedA : public A
{
public:
    SharedA(A* a) : mImpl(a){}
    virtual void setX(int x) {mImpl->setX(x);}
    virtual int getX() const {return mImpl->getX();}
private:
    boost::shared_ptr<A> mImpl;
};

然后 main 函数看起来像这样:

int main()
{
    HelpfulContainer helpfulContainer;

    A* sa1 = new SharedA(new A(1));
    A* sa2 = new SharedA(sa1);
    cout << "*sa1 = " << *sa1 << endl;
    cout << "*sa2 = " << *sa2 << endl;
    sa2->setX(2);
    cout << "*sa1 = " << *sa1 << endl;
    cout << "*sa2 = " << *sa2 << endl;
    cout << "this demonstrates that sa2 is a shared version of sa1" << endl;

    helpfulContainer.eventHorizon(sa1);
    sa2->setX(3);
    //cout << "*sa1 = " << *sa1 << endl;//Bad things would happen here
    cout << "*sa2 = " << *sa2 << endl; 
    //but this line indicates that the originally created A is still safe and intact.
    //only when we call sa2 goes out of scope will the A be deleted.
}

所以,我的问题是:上面的模式是一个好的模式,还是我还没有考虑到什么。我当前的项目继承了一个HelpfulContainer像上面这样删除我需要的指针的类,但我仍然需要 HelpfulContainer 中存在的数据结构。


更新:这个问题是一个后续问题。

4

4 回答 4

6

的全部意义shared_ptr在于它(及其副本)拥有它指向的对象。如果您想为A管理其生命周期的容器提供 an ,那么您根本不应该使用 a shared_ptr,因为它不能满足您的需求;HelpfulContainer只知道如何成为动态创建的对象的唯一所有者,因此您需要给它一个指向不属于其他任何对象的对象的指针。

我认为一个对象关心自己的生命周期通常是糟糕的设计(也有例外)。如果一个对象可以完成一项工作,而其他东西管理它的创建和销毁,选择最简单的生命周期策略(例如本地/自动变量),通常会更有用。

如果您绝对必须在两个不合作的事物(例如shared_ptrHelpfulContainer)之间共享所有权,那么您将不得不使用某种代理技术。

但是,在这种情况下,它看起来HelpfulContainer对您的情况没有太大帮助。

于 2010-12-10T17:03:42.147 回答
1

我不确定这对你有什么作用。

如果helpfulContainer.eventHorizon() 总是删除它的参数,那么为什么不只传递(原始)A 类的新副本:

  helpfulContainer.eventHorizon(new A(sa1));

或者,如果helpfulContainer.eventHorizon() 只是有时删除它的参数,那么调用

  helpfulContainer.eventHorizon(new SharedA(sa1)); 

在选择不删除的情况下,将泄漏SharedA和原始 A (sa1)。

于 2010-12-10T17:09:48.870 回答
0

因此,您正在创建一个可以删除的替身 (SharedA)。尽管这有点尴尬,但我想有必要使用您的旧 API。稍微改进一下:允许从 shared_ptr 构造 SharedA,但不能反过来 - 然后仅在绝对必须时使用 SharedP:

int main()
{
  HelpfulContainer helpfulContainer;

  boost::shared_ptr<A> sa1(new A(1));

  // deletes its parameter, but that's okay
  helpfulContainer.eventHorizon(new SharedA(sa1)); 
}
于 2010-12-10T16:23:40.370 回答
0

对底层指针类型的隐式转换与预期用途不一致,shared_ptr因为您可以非常轻松地将 传递shared_ptr给函数等,而不会意识到这一点。

在我看来,这听起来像是HelpfulContainer任何有用的东西,应该修复或放弃。

如果这不可能,那么最好的方法可能是复制A您要传入的内容并将副本传递给容器。

于 2010-12-10T18:31:05.853 回答