标签: shared-ptr

在使用智能指针的C++项目中,例如boost::shared_ptr,使用" this" 的好设计理念是什么？

考虑一下:

• 存储任何智能指针中包含的原始指针以供以后使用是危险的.您已放弃对对象删除的控制,并信任智能指针以在正确的时间执行此操作.

• 非静态类成员本质上使用this指针.它是一个原始指针,无法更改.

如果我存储this在另一个变量或把它传递给这有可能保存它供以后或在回调绑定它的另一个功能,我创建的引入当有人决定做一个共享指针,以我的课的错误.

鉴于此,我何时适合明确使用this指针？ 是否有设计范例可以防止与此相关的错误？

我在C++的应用程序中使用boost :: shared_ptr.内存问题非常严重,应用程序占用大量内存.

但是,因为我将每个新建对象放入shared_ptr,当应用程序退出时,不会检测到内存泄漏.

必须有一些像std::vector<shared_ptr<> >池持有资源的东西.调试时如何知道谁拥有shared_ptr？

很难逐行检查代码.代码太多......

非常感谢!

我有以下代码片段:

std::vector< boost::shared_ptr<Foo> >::iterator it;
it = returnsAnIterator();
// often, it will point to a shared_ptr that is NULL, and I want to test for that
if(*it)
{
    // do stuff
}
else // do other stuff

我测试正确吗？boost文档说shared_ptr可以隐式转换为bool,但是当我运行这段代码时会出现段错误:

Program received signal SIGSEGV, Segmentation fault.
0x0806c252 in boost::shared_ptr<Foo>::operator Foo*
boost::shared_ptr<Foo>::* (this=0x0)
    at /usr/local/bin/boost_1_43_0/boost/smart_ptr/detail/operator_bool.hpp:47
47              return px == 0? 0: &this_type::px;

shared_ptr的相等运算符定义如下:

template<class T, class U> inline bool operator==(
    shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a.get() == b.get();
}

这似乎破了.把这种平等转移到a和b所指的是不是更好？或者这是对图书馆用户的不公平限制(因为他们必须提供一个平等运营商)？

如果我有一个包含shared_ptrs的map或hash_table,那么当前定义会使等式无法使用.例如,考虑一下

std::map<int, std::tr1::shared_ptr<T> > m1, m2;

我们不想检查m1和m2中每个int的ptrs是否指向相同的值？

我可以通过展平m1,m2 out来实现我自己的相等性(从每个构造集合,沿途取消引用shared_ptrs).是否有一个STL技巧可以完成这个或其他方式在shared_ptrs存在的情况下整齐地测试相等性？

嗨有任何人已经设法使用boost :: serialization序列化C++ 11 std :: shared_ptr.有很多过时的帖子,但没有一个可接受的解决方案.我不打算讨论为什么我要使用std :: shared_ptr只是接受它!

我发现了另一篇帖子:boost serialize和std :: shared_ptr但它没有回答我的问题如何序列化std :: shared_ptr它只建议使用boost :: shared_ptr,这在我的情况下是不可能的.

这篇文章如何将boost :: serialization与来自C++ 11的std :: shared_ptr一起使用？也建议只使用boost :: shared_ptr.

如果有人已经找到了解决std :: shared_ptr序列化问题的工作,我会感兴趣.

嘿家伙我终于找到了我的问题的解决方案,请参阅/sf/answers/1049957751/获取我的答案.

#include <memory>
#include <iostream>

struct A : public std::enable_shared_from_this<A>
{
    ~A()
    {
        auto this_ptr = shared_from_this(); // std::bad_weak_ptr exception here. 
        std::cout << "this: " << this_ptr;
    }
};

int main()
{
    auto a = std::make_shared<A>();
    a.reset();
    return 0;
}

我打电话时遇到std::bad_weak_ptr异常shared_from_this().它是按设计的吗？是的,它可能是危险的,因为在析构函数返回后不能使用此指针,但我没有看到为什么在技术上不可能在此处获取指针的原因,因为共享指针对象显然仍然存在并且可以是用过的.有没有办法绕过这个,没有写我自己的enable_shared_from_this模拟(我宁愿做不到)？

似乎weak_ptr某种方式只知道shared_ptr它的引用何时被破坏了.那个怎么样？是否存在持续的链接或什么？

以下面的代码为例:

weak_ptr<int> test() {
    shared_ptr<int> foo{new int};

    return foo;
}

int main() {
    auto foo = test();

    cout << foo.expired() << endl;
}

当我weak_ptr<int>去检查状态shared_ptr<int>但是没有一个时,我本来期望一个段错误.在weak_ptr<int>正确地识别存储器中作为释放.怎么知道的？

在我的方法中,创建一个Player对象,如:

Player player(fullName,age);

我的老师给了我们一段带有构造函数的代码,该构造函数将shared_ptr带到了一个玩家对象.

//constructor of the class
SomeClass(const std::shared_ptr<Socket> client, std::shared_ptr<Player> player)

让我们说我们想要调用SomeClass的构造函数并传递我们在堆栈上创建的玩家对象.

从堆栈对象创建shared_ptr是否安全/可能/好？

为了使问题更容易理解,我们假设我们有两个大的代码项目,并且我们想要合并它们,以便从另一个项目中调用一个项目的方法,我们是否应该重写所有文件以使用shared_ptr或独立地堆栈对象(对于那些方法而言)需要连接)或者我们应该只为堆栈对象创建一个shared_ptr.

为什么我不确定结果:

如果创建stackobject的范围结束但仍然使用shared_ptr,反之亦然.

stackobject在超出范围时会被删除,或者它是否仍然存活,因为仍然存在对该对象的引用(尽管在另一个类中)？

shared_ptr超出范围并尝试删除对象,即使stackobject引用它也可以吗？

注意:我知道我可以使用以下内容并传递播放器

shared_ptr<Player> player{ new Player {fullName,age} };

从cppreference:

在C++ 11和C++ 14中,std::shared_ptr<T>从以下构造a是有效的std::unique_ptr<T[]>:

std::unique_ptr<int[]> arr(new int[1]);
std::shared_ptr<int> ptr(std::move(arr));

Run Code Online (Sandbox Code Playgroud)

由于shared_ptr从中获取其删除( std::default_delete<T[]>对象)unique_ptr,因此将正确地释放数组.

在C++ 17中不再允许这样做.而std::shared_ptr<T[]>应该使用数组形式 .

为什么在C++ 17中不允许这样做？发生了什么变化？

我现在面临的,我有一个情况std::vector的boost::shared_ptr一个基类的秒.在我的程序过程中,我需要将共享指针存储到该向量中的派生类对象,并且稍后在程序中,需要检索这些共享指针.

以下代码说明了我的问题:

#include <iostream>
#include <vector>
using namespace std;

#include <boost/make_shared.hpp>
#include <boost/foreach.hpp>

class Base
{
public:
    virtual ~Base()
    {
    }
};
/******************************************/

typedef boost::shared_ptr< Base > BasePtr;
/******************************************/

class Derived1 : public Base
{
public:
    void derived1_test()
    {
        cout << "derived1_test" << endl;
    }
    /******************************************/
    int i1;
};
/******************************************/

typedef boost::shared_ptr< Derived1 > Derived1Ptr;
/******************************************/

class Derived2 : public Base
{
public:
    void derived2_test()
    {
        cout << "derived2_test" << endl;
    }
    /******************************************/
    int i2;
}; …