标签: shared-ptr

我有一个对象,它同时定义了复制构造函数和赋值运算符.它包含在共享指针中.

我想创建另一个共享指针,其中包含原始共享指针的副本(即指向新内存位置的新共享指针,但是,它与原始对象具有相同的数据).

谢谢你的帮助.

我有以下课程

class Parent {
  virtual void doStuff() = 0;
};

class Child : public Parent {
  void doStuff() {
    // Some computation here
  }
};

我有一个具有以下签名的功能.

void computeStuff(std::vector<boost::shared_ptr<Parent> >);

如果我可以重构我的代码(包括函数签名),那么将函数传递computeStuff给Child对象列表的最佳方法是什么？

从本质上讲,我希望编译和运行以下代码片段

std::vector<boost::shared_ptr<Child> > listOfChilds = getList();
computeStuff(listOfChilds);

考虑以下代码:

#include <queue>
#include <memory>

std::shared_ptr<char> oneSharedPtr(new char[100]);

std::queue<std::shared_ptr<char>> stringQueue;
stringQueue.queue(oneSharedPtr);

这导致了

error C2274: 'function-style cast' : illegal as right side of '.' operator

为什么是这样？在队列中使用共享指针是否安全(共享指针的引用计数在弹出时是否会变为0)？

为了将shared_ptr分配给柠檬图库中的Graph类型变量,我这样做了:

typedef ListDigraph Graph;
typedef std::shared_ptr<Graph> Process_pointer;
Process_pointer process(new Graph);

它运行正常,但现在我需要为地图对象声明一个shared_ptr,通常地图对象的工作方式如下:

Graph process;
typedef ListDigraph::NodeMap<string> Node_names;
Node_names name(process);

也就是说,name需要Graph对象作为其默认构造函数.

为了声明一个shared_ptr,我这样做了:

typedef ListDigraph::NodeMap<string> Node_names;
typedef std::shared_ptr<Node_names> Nname_pointer;
Nname_pointer name = new Node_names;
name(process);

我知道,名称的声明是错误的,但我如何分配内存以及用进程对象初始化它.

标题几乎说明了一切,我几乎肯定它是复制构造函数或赋值运算符,我很确定它是后者.这是一个非常短的课程,所以我会发布整个事情,任何关于如何处理它的建议都会很好.老实说我在这里也有点过头了,所以任何指向一些可靠阅读的人都会非常感激.

#pragma once

//for non-learning purposes, boost has a good smart pointer
template <class type>
class sPtr
{
private:
    type *p;
    int r; //referenceCount

    void add()
    {
        r++;
    }
    int release()
    {
        return --r;
    }
public:
    sPtr(): p(NULL), r(1) {}
    sPtr(type *pValue): p(pValue)
    {
        add();
    }
    sPtr(const sPtr<type> & sp): p(sp.p), r(sp.r)
    {
        add();
    }
    ~sPtr()
    {
        if(release() == 0)
        {
            delete p;
        }
    }

    type* get()
    {
        return p;
    }

    type& operator*()
    {
        return *p;
    }
    type* operator->()
    { …

从c ++ 11开始,我可以在不创建和删除原始指针的情况下编写代码.但这是正确的方法 - 我应该总是使用智能指针(共享,独特或弱)或者是否有我应该自己删除对象的情况？

也许以前曾经问过这个问题,但我从未找到过满意的答案.此外,为简单起见,我假设我在谈论单线程应用程序.

所以,我多次听到的是,如果你有一个非拥有的对象并且它的生命周期得到保证,你应该用原始指针引用它.对象的所有者将使用unique_ptr,并根据需要分发原始指针.

但是,如果该对象是非拥有的,并且生命周期无法保证怎么办？然后你可以使用weak_ptr,是的.但是,任何交给weak_ptr的人都可能是顽皮的并保持锁定状态,这样对象的所有者就不会导致对象被破坏.有时这可能不是问题,但有时也是如此.例如,当拥有的对象表示某个必须在特定时间放弃的系统资源时.

你可能会说"好吧,那么你应该确保没人阻止weak_ptr锁定!" 但是从OO设计的角度来看,这在我看来并不理想,因为它在"所有者"对象和从中获取weak_ptr的任何对象之间创建了依赖关系.您也可以创建参数"您不需要返回const引用;您应该确保没有人修改引用."

有了Qt,你有QPointer,这基本上就是我正在寻找的.它检查对象是否已被销毁,但它无法阻止对象被销毁.我意识到这不是线程安全的,但同样,我在谈论单个线程的上下文.

那么为什么C++ 11没有类似的东西呢？我确信我可以在weak_ptr周围创建一个包装器来完成我所追求的目标.但是我想知道我是不是错了.

我有一个priority queue班级,像这样:

    class Foo
    {
    public:
        //public methods...
    private:
        std::priority_queue<Obj, std::vector<Obj>, object_less> foo_queue;

        //private methods and members...
    }

我一直在使用该emplace()方法在我的内部插入对象priority_queue,如下所示:

void Foo::add( ... ) {
    foo_queue.emplace(var1, var2);
}

这将调用构造函数Obj(var1,var2)并将其插入到priority queue.

但现在,我需要std::vector<Obj>从外面访问.从我的Obj对象.

类似于创建一个Foo object和更改成员的东西,它位于以下对象内priority_queue:

Foo myFoo; // <-- this is where the priority_queue is!

Obj myObj(1); //Creating an object that has some member with value '1'

myFoo.add(myObj); //This will add the object to the …

我有一个体素结构:

struct voxel
{
    unsigned char R, G, B;
    voxel()
    {
        R = G = B = 0;
    }
    //parameteric contructor with parameters
    voxel(unsigned char pR, unsigned char pG, unsigned char pB)
    {
        R = pR; G = pG; B = pB;
    }
};

对于体素的数量,我有一个非常大的n.

int n = 300 * 300 * 300;

现在,当我用向量初始化体素时,RAM大约需要79 MB.

std::vector< voxel > vi(n);

但是当我使用shared_ptr和堆栈溢出以这种方式初始化时,它需要超过2 GB.

std::vector< std::shared_ptr<voxel> > vi(n);
for (size_t i = 0; i < n; i++)
{
    vi.push_back(std::shared_ptr<voxel>(new voxel()));
}

这种行为可能是什么原因,我该如何避免呢？

补充说明: …

在这个例子中

std::shared_ptr<obj> ptr = new obj("old");
ptr.reset(new obj("new"));

obj("new")将首先调用will 的构造函数,然后调用will的析构函数obj("old").

有没有办法首先破坏obj("old")然后再构建obj("new")？(除ptr.reset()先致电然后致电ptr.reset(new obj("new")))