标签: shared-ptr

我正忙着设计一个新的C++应用程序.在这个应用程序中,我想用指针最小化潜在的错误,并且由于应用程序应该是普通的C++(没有.Net或其他奇特的东西),我正在调查共享指针,我正在考虑在任何地方使用共享指针(而不是普通的指针).

我制定了一些技巧,以便更容易使用共享指针,例如:在类中使用typedef,如下所示:

class X
   {
   public:
      ...
      typedef std::shared_ptr<X> Ptr;
   };

这样你就可以轻松编写X :: Ptr,它比"std :: shared_ptr"更容易编写.

我还注意到共享指针的一些缺点:

• 无处不在我使用我需要包含的共享指针 <memory>
• 如果我只想使用指针,我就不能再使用前向声明了

还有其他技巧可以让共享指针更容易使用吗？

我有一个类使用一些回调来进行计算.那些回调需要分配需要在回调范围之外生存的数据(动态数组),而不是在类破坏之后.我想过当一个类破坏时vector,auto_ptr它会自动被破坏:

class MyClass
{
    vector<auto_ptr<MyObject>> ThingsToDie;
};

问题是我分配了很多对象,并且它们不共享基类型,所以我不能使用vector它,并为每种类型制作一个向量是很多工作.
如下所示的层次结构:

auto_ptr_base (virtual destructor)
      |
 auto_ptr<T>

将解决我的问题,因为我可以做类似的事情

class MyClass
{
    vector<auto_ptr_base> ThingsToDie;
};

并且将自动将销毁实际分派给每个专用类型.
问题是STL没有那个层次结构,我不想重新实现auto_ptr.
还有其他解决方案吗？

我有些惊讶地发现,std::shared_ptr当它的指向对象以某种方式被删除时,它不提供保护(例如,抛出异常).我想这是出于性能原因; 假设shared_ptr正在完成其工作的对象shared_ptr应该从未删除过的点,因此浪费周期不断检查是愚蠢的.

我知道我可以明确检查a shared_ptr是否有效,但是如果shared_ptr"做它的工作"来维持对象的生命周期,那么每次触摸时都要明确检查是否有点过分shared_ptr.

所以我的问题是,鉴于此,我应该多么谨慎？关于是否,经常或何时应该检查shared_ptr？是否有"经验法则" ？

到目前为止,我最好的结论是模仿Java:每当你提交一个你没有创建的Java对象的引用时,你应该检查它null.这是一个很好的政策shared_ptr吗？

我目前有矢量,如:

vector<MyClass*> MyVector;

我访问使用

MyVector[i]->MyClass_Function();

我想利用shared_ptr.这是否意味着我所要做的就是将我vector改为:

typedef shared_ptr<MyClass*> safe_myclass

vector<safe_myclass>

我可以继续使用我之前的其余代码吗？

我用boost shared_ptr头文件编写了一个程序.如何编译这个程序？我-l在编译时提到了g ++选项的库.

QVector<QSharedPointer<SomeData> > DataVec在一个面向对象的大项目中,我有一个班级的领域.程序在循环执行代码部分期间获得内存溢出,其中分配了大内存,由QSharedPointers控制.

在程序运行周期中,DataVec充满了

DataVec.push_back(QSharedPointer<SomeData>(new SomeData()));

QSharedPointer调用后会被删除(发布)DataVec.pop.back()还是DataVec.clear()？

我想不是.我们必须显式调用析构函数QSharedPointer(我在Qt中也看不到像boost :: shared_ptr :: reset()这样的方法).比,SomeData默认的析构函数(SomeData只有标准Qt容器为域)将被调用,如果我们没有更多的QSharedPointers那点SomeData实例而言,和内存将被释放.现在,我只做pop_back():似乎,我只是松散指向未发布的数据(执行后,valgrind表示我肯定丢失了块,我想它们来自这里).

所以,最后,我是对的吗？我怎样才能QSharedPointer以正确的方式从容器中删除？

编辑1:Qt中的boost :: shared_ptr :: reset()方法是QSharedPointer::clear().

在此先感谢帮助的人们.我是C++的新手.我正在学习智能指针/共享指针的概念并使用Visual Studio 2013RC.按照维基百科中的示例,我创建了一个像这样的共享指针

SharedPointer.cpp

#include <iostream>
#include <memory>
//using namespace std;
void main(){
    std::shared_ptr<int> sp1(new int(5), std::default_delete<int[]>());
    //std::shared_ptr<int> sp2 = sp1;
    for (int i = 0; i < 5; i++)  sp1.get()[i]= i;
    for (int i = 0; i < 5; i++) std::cout << sp1.get()[i] << std::endl;
    system("pause");
}

该程序编译并打印出0,1,2,3,4没有任何错误,但随后出现了"SharedPointer.exe触发断点"的窗口.

谁能告诉我这个例外的原因是什么？

非常感谢

我有两种类型:A和B.'聪明'指向B和B'聪明'指向A.在主要范围内,我有一个指向A的智能指针.

class A;
class B;
typedef shared_ptr<A> pA;
typedef shared_ptr<B> pB;

class B {
public:
    B() {}
    pA a;
    virtual ~B() {cout << "delete b" << endl;}
};

class A {
public:
    A() : b(new B()) {}
    pB b;
    virtual ~A() {cout << "delete a" << endl;}
};

int main(int argc, char **argv)
{
    {
        pA pa(new A());
        pa->b->a = pa;
    }
    cout << "here" << endl;

}

我希望在范围的末尾删除这两个对象.没有任何对象被删除,因为A有两个指向自身的指针(一个在b中,一个在主勺中).

这是一个简单的例子.实际上我有两种以上的类型和更多的指针.可以想象一个大的对象结构指向彼此浮动在RAM中,只有一个指针从主范围指向这个结构.我希望在释放此指针后删除此结构.

我使用以下代码建立一种注册表类:

class MyClass 
{
    public:
       int a;
       std::string b;
};

class Register
{
    public:
        std::vector<std::shared_ptr<MyClass>> items;

        bool registerItem(std::shared_ptr<MyClass> item)
        {
            /*
             * Check if item exists
             */
            auto position = std::find(items.begin(), items.end(), item);

            if (position != items.end())
                return false;

            items.push_back(item);

            return true;
        }

         bool unregisterItem(std::shared_ptr<MyClass> item)
        {
            auto position = std::find(items.begin(), items.end(), item);

            if (position == items.end())
               return false;

            items.erase(item);

            return true;
        }
};


int main()
{
    std::shared_ptr<MyClass> item1 = new MyClass;

    Register registry;

    if (!registry.registerItem(item1))
        std::cout << "Error registering …

为了保存对象的引用,使用和不使用std :: shared_ptr之间的区别是什么？

class A{};

class B
{
private:
    std::shared_ptr<A>&obj; // or std::shared_ptr<A>obj;
public:
    B(std::shared_ptr<A>r) : obj(r) {}
};

int main()
{
    std::shared_ptr<A>a(new A());
    std::unique_ptr<B>b(new B(a));
    std::cin.get();
    return 0;
}