标签: shared-ptr

我希望从一个池分配一个shared_ptr管理的对象,比如Boost的Pool接口,怎么能实现呢？

在尝试围绕这个问题中显示的问题时,我发现自己陷入了[util.smartptr.shared]/4中的以下句子:

[...]更改use_count()不反映可能引入数据争用的修改.

我不明白我应该怎么读,以及我应该得出什么结论.以下是一些解释:

• 调用use_count()不会引入数据争用(但这应该由该const函数的-ness单独保证,以及相应的库范围保证)
• 返回的值use_count()不受("不反映"？)影响需要原子性或同步的操作的结果(但这些相关操作是什么？)
• use_count() 以原子方式执行,但不会阻止CPU或编译器重新排序(即没有顺序一致性,但为什么不提及特定模型？)

对我来说,上述任何一个似乎都没有从那句话中得出,而我却在试图解释它.

我有一个关于std::unique_ptr和的问题std::shared_ptr.我知道有很多关于何时使用哪一个的问题,但我仍然不确定我是否正确理解它.我在某处读到了智能指针的默认选择std::unique_ptr,但据我了解,我应该更喜欢使用std::shared_ptr.例如,我有:

class B;
class A
{
private:
   B* b;
public:
   B* getB();
};

A::getB()
{
   return b;
}

所以基本上类A拥有指向类型对象的指针,B并且有一个返回该指针的方法.如果我创建了getter,我假设其他一些类可以访问这个指针,因此它应该shared_ptr代替unique_ptr.我是对的,还是我还没有得到它？

在我从前一个问题的答案中提示之后编写了一些东西,我遇到了重载Scene :: addObject的问题.

重申相关位并使其自包含,尽可能少的细节:

• 我有继承对象的层次Interface,其中有FooS和BarS;
• 我有一个Scene拥有这些物品的人;
• Foos应该是unique_ptrs和Bars将shared_ptr在我的主要(由于前一个问题中解释的原因);
• 将main它们传递到Scene实例,其取得所有权.

最小的代码示例是这样的:

#include <memory>
#include <utility>

class Interface
{
public:
  virtual ~Interface() = 0;
};

inline Interface::~Interface() {}

class Foo : public Interface
{
};

class Bar : public Interface
{
};

class Scene
{
public:
  void addObject(std::unique_ptr<Interface> obj);
//  void addObject(std::shared_ptr<Interface> obj);
};

void Scene::addObject(std::unique_ptr<Interface> obj)
{
}

//void …

我有一个功能,需要一个shared_ptr<MyClass>.在某些成员函数memfun中MyClass,我需要传递this给该函数.但如果我写

void MyClass:memfun()
{
   func(shared_ptr<MyClass>(this))
}

我假设在呼叫结束后,引用计数将达到0并且this将被尝试销毁,这是不好的.

然后我记得那个类enable_shared_from_this有这个功能shared_from_this.

所以现在我将使用以下内容:

class MyClass: public enable_shared_from_this<MyClass>
{
    void MyClass:memfun()
    {
       func(shared_from_this());
    }
};

问题是:

1)绝对不可能在不衍生的情况下使用该功能enable_shared_from_this吗？
2)是否enable_shared_from_this意味着在具有自动存储持续时间的对象上调用memfun会导致不好的事情？例如

 int main()
 { 
    MyClass m;   //is this OK?
    m.memfun();  // what about this?
 }

3)如果我从MyClass派生,是否会正确继承enable_shared_from_this功能,还是需要再次派生？那是,

class MyCoolClass: public Myclass
{
   void someCoolMember
   {
      someCoolFuncTakingSharedPtrToMyCoolClass(shared_from_this());
   }
}

这个可以吗？或者正确如下？

 class MyCoolClass: public Myclass, public enable_shared_from_this<MyCoolClass>
    {
       void someCoolMember …

我知道有一个用于序列化的Boost模块boost::shared_ptr,但我找不到任何东西std::shared_ptr.

另外,我不知道如何轻松实现它.我怕以下代码

namespace boost{namespace serialization{
template<class Archive, class T>
inline void serialize(Archive & ar, std::shared_ptr<T> &t, const unsigned int version)
{
  if(Archive::is_loading::value) {T*r;ar>>r;t=r;}
  else {ar<<t.get();}
}
}}//namespaces

不起作用.实际上,如果某个对象被多次引用,它将被第一次运行加载ar>>r,之后只会复制一个指针.但是,我们会创建shared_ptr指向它的多个对象,因此会多次破坏它.

有什么想法吗？

关于我正在使用的系统的一些技术细节:

• 操作系统:Ubuntu 11.10(x64)
• 编译器:g ++(Ubuntu/Linaro 4.6.1-9ubuntu3)4.6.1
• 升级版:1.46.1(已安装sudo apt-get install libboost-dev)

buffer = new char[64];
buffer = std::make_shared<char>(char[64]); ???

你可以使用make_shared<>()？为数组分配内存吗？

我可以: buffer = std::make_shared<char>( new char[64] );

但这仍然涉及呼唤新的,这是我的理解make_shared更安全,更有效.

当我发现标准定义std::unique_ptr并且std::shared_ptr以两种完全不同的方式关于指针可能拥有的Deleter时,我认为这很奇怪.这是来自cppreference :: unique_ptr和cppreference :: shared_ptr的声明:

template<
    class T,
    class Deleter = std::default_delete<T>
> class unique_ptr;

template< class T > class shared_ptr;

正如您所看到的,unique_ptr将"Deleter"对象的类型"保存"为模板参数.这也可以通过稍后从指针中检索Deleter的方式看出:

// unique_ptr has a member function to retrieve the Deleter
template<
    class T,
    class Deleter = std::default_delete<T>
>
Deleter& unique_ptr<T, Deleter>::get_deleter();

// For shared_ptr this is not a member function
template<class Deleter, class T>
Deleter* get_deleter(const std::shared_ptr<T>& p);

有人可以解释这种差异背后的理性吗？我明显赞成这个概念,unique_ptr为什么这不适用于此shared_ptr？另外,为什么get_deleter在后一种情况下会成为非成员函数呢？

当智能指针涉及应用程序时,我一直在阅读有关性能问题的大量讨论.其中一个常见的建议是将智能指针作为const而不是副本传递,如下所示:

void doSomething(std::shared_ptr<T> o) {}

与

void doSomething(const std::shared_ptr<T> &o) {}

但是,第二种变体实际上是否会破坏共享指针的目的？我们实际上在这里共享共享指针,因此如果由于某些原因在调用代码中释放指针(想到重入或副作用),则const指针变为无效.共享指针实际应该阻止的情况.我理解const&节省了一些时间,因为没有涉及复制,也没有锁定来管理引用计数.但是价格让代码不那么安全了吧？

这里有一个简单的问题:您是否可以明确删除boost::shared_ptr自己？你应该吗？

澄清,我不是说删除指针所持的指针shared_ptr.我的意思是实际的shared_ptr.我知道大多数人建议不要这样做,所以我只是想知道是否可以明确地做到这一点.