来自指针的boost :: shared_ptr

时间:2014-03-03 13:38:47

标签: c++ boost

我偶然发现了boost :: shared_ptr文档,其中包括:

Sometimes it is necessary to obtain a shared_ptr given a raw pointer
to an object that is already managed by another shared_ptr instance.
Example:

void f(X * p) 
{
    shared_ptr<X> px(???);
}

Inside f, we'd like to create a shared_ptr to *p.

In the general case, this problem has no solution.

为什么呢?是不允许做类似的事情:

shared_ptr<X> px(p);

我错过了什么吗?

5 个答案:

答案 0 :(得分:3)

如果您有一个shared_ptr管理指针,然后创建另一个shared_ptr来管理同一个指针(不复制原始的shared_ptr),那么最终会有两个管理器用于同一个资源。当其中一个达到引用计数0时,它将删除该对象,而另一个shared_ptr将指向已删除的内存以及随后的所有内容。

答案 1 :(得分:0)

如果你这样做:

main() {
  Object *obj = new Object();
  func(obj)
}

void func( Object *obj ) {
  shared_ptr objPtr(obj); // take ownership.
  objPtr->fun();
  // Passed object "obj" is destroyed here.
}

在函数func的末尾,对象指针将被销毁,并且指针指向对象本身。这不是一个理想的行为。

答案 2 :(得分:0)

实际上,你可以这样做,但你必须知道在退出函数时将删除指向的对象......

我尝试使用boost:

void f(X * p)
{
    boost::shared_ptr<X> px(p);
    // do smething
}

void main()
{
    X* ptr = new X();
    f( ptr );
    // ptr is not valid anymore because the object were deleted
}

答案 3 :(得分:0)

不可能这样做。

共享指针使用引用计数。将资源(原始指针)分配给共享指针时,将使用count = 1创建引用计数对象。当为同一资源创建另一个共享指针时,引用计数对象(在两个共享指针之间共享)将更新为值count = 2。如果删除了一个共享指针,则共享引用对象中的计数将减少,当它达到0时,资源将被销毁。

要使上述机制起作用,应使用shared_ptr px(p)和后续的所有使用px(不是&#39; p&#39;)创建第一个共享指针。这样,创建的所有共享指针都将知道它们持有相同的资源并共享相同的引用计数对象。

如果使用shared_ptr px(p)创建了另一个共享指针,那么最终会得到两个彼此不相关的共享指针 - 即引用计数对象不相同。他们都假设他们持有不同的资源,并且他们每个都有不同(不同)引用计数对象,其中count = 1。 (你不想要这个。)

答案 4 :(得分:0)

你可以这样做,但它可能导致未定义的行为,因为没有办法告诉第二个共享指针引用计数(指向同一个对象的共享指针的数量)增加。那么这样的事情可能会发生:

void f()
{
    boost::shared_ptr<int> firstSmart(new int(23)); // firstSmart is the only 
                                                    // manager of the int
    int *raw = firstSmart.get();
    boost::shared_ptr<int> secondSmart(raw);        // secondSmart also manages
                                                    // the same int as firstSmart
                                                    // but secondSmart does not 
                                                    // know about firstSmart
                                                    // and vice versa
}

f退出secondSmart被销毁时,会破坏共享的int。然后firstSmart被破坏并试图销毁已经被破坏的int,从而导致未定义的行为。