标签: shared-ptr

我正在尝试将shared_ptr与我的班级一起使用但由于某种原因我得到了段错误.也许我做的事情很愚蠢.

#include <tr1/memory>
#include <iostream>
class Dataset ;
typedef int DataClass;
class Dataset_Impl{
    friend class Dataset ;
    DataClass *dc;
    Dataset_Impl(){dc = new DataClass[10];}
    public:
    void getSubset(Dataset_Impl* &dObj){
        dObj = new Dataset_Impl();  //Causing segfault when using shared_ptr
        /*copy subset of 'dc' to dObj->dc and return*/std::cout<<"Copied subset";
    }
};
class Dataset{
    Dataset_Impl *d;
    public:
        Dataset (){};
        inline void const getSubset(Dataset &dObj) const{d->getSubset(dObj.d);}
};
int main(){
    Dataset m1,subset1;std::shared_ptr<Dataset> subset2;
    m1.getSubset(subset1);
    m1.getSubset((*subset2)); //Causing segfault
}

我知道这个问题已被要求死亡,但我想知道是否有任何方式做我在问题中所说的而不使用Boost库指针等.基本上我有以下一段清理代码删除指向的对象通过二维QList中的指针(QList <QList>)

#include <QList>
QList< QList<MyObject*> > m_Data;
...
void CleanupMyObjectList
{
int numFrames = m_Data.size();
for(int i=0; i < numFrames; i++)
{
    int numObjects = m_Data.at(i).size();

    for(int j=0; j < numObjects; j++)
    {
        MyObject* removedObject = m_Data[i].at(j);
        if(removedObject != NULL)
        {
            delete removedObject;//This assumes that the pointers are UNIQUE in this list!!! If not it will crash!!!
            removedObject = NULL;
        }
    }
    m_Data[i].clear();

}

m_Data.clear();
}

当我尝试清理由非唯一或共享(这是正确的术语？)指针填充的列表时,它确实崩溃了,例如当m_Data [0] [1]等于m_Data [1] [1]时.

我知道为什么它崩溃所以请保存解释,但我想知道是否有安全删除这些对象尽可能少的代码修改.

我有几个通过指针共享数据的对象.指针参数是在构造函数中发送的,如下所示.

class A
{
public:
    Shared* pB = new Shared();
    User* object1 = new User(pB);
    User* object2 = new User(pB);
}

class User
{
public:
    User(Shared* pB) {m_sharedB = pB};
private:
    Shared* m_sharedB;
}
class Shared
{
public:
    struct Account 
    {
        int account_number;
    }
    void method(){...};
}

我的问题与C++析构函数有关.当object1被删除时,成员变量"m_sharedB"会发生什么？是否存在悬挂指针给其他同行的问题？

下面的代码在取消注释时崩溃,似乎get()中的shared_array <>参数有问题.

print()似乎至少暂时没有崩溃......

传递shared_array <>参数的正确方法是什么？

#include <iostream>
#include <cstring>
#include <boost/shared_array.hpp>
using namespace std;
using namespace boost;

shared_array<wchar_t> get(const wchar_t* s) {
//shared_array<wchar_t> get(const shared_array<wchar_t>& s) {

    size_t size = wcslen(s);
    //size_t size = wcslen(s.get());

    shared_array<wchar_t> text(new wchar_t[size+1]);

    wcsncpy(text.get(), s, size+1);
    //wcsncpy(text.get(), s.get(), size+1);

    return text;
}

void print(shared_array<wchar_t> text) {
    wcout << text.get() << endl;
}

int wmain(int argc, wchar_t *argv[]) {
    //shared_array<wchar_t> param(argv[1]);

    shared_array<wchar_t> text = get(argv[1]);
    //shared_array<wchar_t> text = get(param);

    print(text);
    //print(text.get()); 
}

编辑:谢谢.所以关键在于我在使用boost :: shared_ptr/array时应该总是只使用new/new []. …

std::shared_ptr<T>和之间有什么区别std::shared_ptr<T const>？

什么时候你会使用一个与另一个？

只是想澄清一下shared_ptr

int main(){
   typedef std::tr1::shared_ptr<Foo> _foo;

   _foo obja(new Foo());
   Foo *objb = obja.get(); 

   // delete objb; //deleting objb will throw double free or corruption
   return 0;
}

在上面的代码中,如果未删除或释放objb,是否存在内存泄漏？最终,obja将超出范围并将自由.由于objb和obja指向同一个实例,这意味着没有必要释放objb？

以上是否与此相同:

Foo *obja = new Foo();
Foo *objb;

objb = obja;
delete obja;

我有一个指向对象的指针向量,并且在某些时候,使用该向量的子元素创建第二个向量.现在,对原始向量进行排序会更改第二个向量中的元素(排序后其中的元素完全不同).

这是预期的行为吗？它与make_indirect_iterator有关吗？有没有更好的解决方案(假设我想保留一个指针向量)？

std::vector<std::shared_ptr<MyObj>> vecAll;
std::vector<std::shared_ptr<MyObj>> vecSub;

// fill vecAll with something...

for(auto obj : vecAll) {
    if( obj->x >=0 ) {
        vecSub.push_back(obj);
    }
}

// 3 objects in 'vecSub'

std::sort(boost::make_indirect_iterator(vecAll.begin()), boost::make_indirect_iterator(vecAll.end()), std::greater<MyObj>());

// now there are 3 DIFFERENT objects in 'vecSub'

我有以下愚蠢的代码:IDEONE

有人可以解释,为什么删除std :: vector中的对象A时全局计数器不会增加？

#include <iostream>
#include <memory>
#include <vector>

int global;

class A {
public:
    A(int i): a(i) {}
    ~A() {
        std::cout << "delete A" << std::endl;
        ++global;
    };
    int foo() {
        return a;
    }
    int a;
};


int main() {


        int c = 0;
        int loops = 10;
        global = 0;

        // Make vector of pointers
        std::vector<std::shared_ptr<A> > vec;
        for(int i = 0; i< 10; i++) {
            vec.push_back( std::shared_ptr<A>(new A(i))    );
        }

        for(int i=0; i<loops; i++) { …

让我们p成为共享/唯一指针.是if (p)与if (p.get())相同呢？

如果不是,这些条件或条件中的代码在什么情况下表现不同？

从cppreference我读到std::shared_ptr::operator bool检查是否get() != nullptr.这是确切的实施operator bool吗？

我已经决定转向现代的c ++实践,我试图调整我的旧代码来使用智能指针.我有一个数据包类,包含数据包数据,以及其他一些变量.

class Packet
{
public:
    Packet(int connId, std::shared_ptr<char[]> buff, size_t pLen) 
        : connID(connId), packetLen(pLen)
    {
        buffer = buff;
    }

    Packet(){}

    int connID;
    size_t packetLen;
    std::shared_ptr<char[]> buffer;
};

我有一个测试功能,可以在新分配的缓冲区中创建和插入数据.

std::vector<Packet> packetV;

void createPacket()
{
    std::shared_ptr<char[]> data = std::make_shared<char[]>(10);

    for (int i = 0; i < 5; ++i)
    {
        uint8_t byte = 5;
        memcpy(*data.get() + i, &byte, sizeof(uint8_t));
    }

    packetV.push_back(Packet(1, data, 5*sizeof(uint8_t)));
}

//(Main function)
void main()
{
    std::string input;
    do
    {
        std::cin >> input;
        if (input == "packet") createPacket();
        else …