关于删除C ++指针

Question

好..所以这让我感到困惑。 我正在处理一些我感觉有些旧的C ++代码部分，但这并不安全，但我不是100％肯定的。 这是一个片段，例如高风险的东西。

struct A {
    A() : a_ptr(0) {}
    A(some_type *ptr) : a_ptr(ptr) {}
    const some_type *a_ptr;
};

struct B {
    B() : b_ptr(0) {}
    B(some_type *ptr) : b_ptr(ptr) {}
    const some_type *b_ptr;
};

struct Data {
    Data(...) {//-Stuff that doesn't invole aptr_list or bptr_list;
    }
    ~Data() {
        for(std::vector<A*>::iterator itr = aptr_list.begin(); itr != aptr_list.end() ++itr) {
            delete *itr;
        }
        for(std::vector<B*>::iterator itr = bptr_list.begin(); itr != bptr_list.end() ++itr) {
            delete *itr;
        }
    }
    std::vector<A*> aptr_list;
    std::vector<B*> bptr_list;
private:
    Data(const Data&);
    Data& operator=(const Data&);
};

然后在实现中，我发现：

void some_func(...) {
    //-Inside some function
    Data& d = get_data(...);
    ...
    for(...) {
         some_type *sptr = dynamic_cast<some_type*>(a_source_of_some_type_pointer);
         A* a = new A(sptr);
         B* b = new B(sptr);
         d.aptr_list.push_back(a);
         d.bptr_list.push_back(b);
    }
}

我对上面的实现中使用的同一指针sptr感到不安； 调用Data的析构函数时是否会产生问题？ 另一方面，看起来我们有两个new的A*和B*调用，正好有两个delete s，所以如果Data的析构函数不深-也许那是我需要澄清的地方，那么也许这毕竟是安全的而我的担心放错了地方？ 我确实注意到，例如结构A和B没有定义任何析构函数，所以我希望它不深。 但是我不确定这是否意味着它们的指针数据将被释放。 一如既往地欣赏专家的见解。

感谢您的时间和关注。

Answer 1

A和B没有用户定义的析构函数，因此a或b任何事物都不会被破坏（除了它所释放的实际内存之外，但是由于sptr仅保存在这里，因此不会被deleted ）。 [很明显，如果A或B包含其他类，请说一个std::string或std::vector ，该类将被销毁]。

因此，换句话说，你的代码是蛮好喜欢它- a和b仅持有的副本sptr ，但它永远不会被删除[在此位的代码，如果它需要以后删除，那是另一回事。

Answer 2

Data::~Data() sptr Data::~Data()不会破坏sptr指针。 它只会调用A::~A()和B::~B() 。

我不确定您要做什么，但是如果您想进行深层销毁，则需要确保您没有释放以前已经有人释放过的内存地址。

这取决于实现要求，但是理想情况下，分配对象的用户也应该有空。 因此，由于此sptr是由其他人分配的，因此，如果释放它，则可能会得到一个悬空的指针。

Answer 3

sptr不归A或B所有，所以这是正确的。

Answer 4

如果我们真的可以确定，那么代码可能会泄漏。

如果d.aptr_list.push_back()需要并且无法保留更多的容量，则a和b指向的内存将泄漏。

for(...) {
     some_type *sptr = dynamic_cast<some_type*>(a_source_of_some_type_pointer);
     A* a = new A(sptr);          // Allocate memory
     B* b = new B(sptr)           // Allocate memory (and missing semicolon!!)
     d.aptr_list.push_back(a);    // If this fails,
     d.bptr_list.push_back(b);    // or this,
}                                 // then exception is thrown and memory is lost
                                  // (unless you catch the exception and
                                  // perform a delete).

为了安全起见，应该使用类似std::unique_ptr的智能指针来包装指针。

您的列表应为std::vector<std::unique_ptr<A>>和std::vector<std::unique_ptr<B>> 。

在some_func ，代码可以读取如下内容：

some_type *sptr = dynamic_cast<some_type*>(a_source_of_some_type_pointer);
d.aptr_list.push_back(std::unique_ptr<A>(new A(sptr)));
d.bptr_list.push_back(std::unique_ptr<B>(new B(sptr)));