相关疑难解决方法(0)

让我们说吧

class A {
  A* array;
public:
   A (){ 
    array= new A [4];
  }

  ~A (){
    delete array;
  }
}

如果我们在堆上创建这样的对象,我们如何释放对象

A* object_ptr =new A();

我对释放指向包含另一个指针的对象的指针感到有点困惑.....

以下哪项是避免内存泄漏的正确方法？

//Option A
char* data = new char[4];
data = new char[5];
delete[] data;

//Option B
char* data = new char[4];
delete[] data;
data = new char[5];
delete[] data;

我尝试学习如何使用智能指针。我长期使用普通指针，我认为我需要升级我的技能。

我做了一些研究，我了解智能指针的某些方面，但我尝试在一个清晰的项目中实施，以了解智能指针是如何工作的。我尝试：

#include <iostream>
#include <array>
#include <memory>

class Entity
{
public:
    Entity()
    {
        std::cout << "Entity called!" << std::endl;
    }
    ~Entity()
    {
        std::cout << "Entity destroyed!" << std::endl;
    }
    void print() { std::cout << "Message!"; }
};

int main()
{
    std::shared_ptr<int>f1(new int[100]);

    f1.get()[1] = 1;
    std::cout << f1.get()[1];
}

一切都很好，消息是打印的。但是当我尝试：

#include <iostream>
#include <array>
#include <memory>

class Entity
{
public:
    Entity()
    {
        std::cout << "Entity called!" << std::endl;
    }
    ~Entity()
    {
        std::cout << "Entity destroyed!" << std::endl;
    }
    void …

我非常肯定它是,但如果我正确解释标准(第18.6.1.2节new.delete.array)提到:

void operator delete [](void*ptr)noexcept; 指针.

.13默认行为:调用operator delete(ptr)

因为在默认行为中delete []只调用它的delete(ptr)等价物,为什么调用哪个版本有关系？我尝试使用示例代码来验证这一点并且崩溃使得更明显的是不匹配的新[]和删除确实导致了不好的事情

#include <iostream>
#include <memory>
class foo{
    public:
        void bar(){
            std::cout << "foo's bar" << std::endl;
        }
        ~foo(){
            std::cout << "foo dies after this" << std::endl;
        }
};
int main() {
    std::shared_ptr<foo> x(new foo[10]);
    return 0;
}

如何解释标准中的上述引用线？

我有一个对象O1,它有指针.我通过复制构造函数创建了另一个对象O2.指针地址将被复制到对象O2中.当我离开O2的范围时,它将被删除.析构函数也将删除指针.这使得对象O1中的指针变得悬空.如何确保只有当我从O1出来时才删除指针.

在简短描述中,仅当没有其他人直接或间接引用该指针时,如何删除该对象指针.

class info {
    public:
        char *buf;
        int len;
        info(int l) {
            len = l;
            buf = new char[len];
            buf[0] = 'h';
        }
        ~info() {
            delete[] buf;
        }
};
int main() {
    info O1(100);
    cout << O1.buf << "\n";
    {
        info O2(O1);
    }
    cout << O1.buf << "\n";
}

这里主要结尾处的O1的析构函数将获得一个SIGABT信号,用于尝试释放已经通过O2删除的O1.buf引用的内存.

将shared_ptr复制到数组:是否应该使用它？

根据这篇文章,使用smart_ptr包装数组的好方法是定义一个删除函数,并将删除函数单独传递给带有原始数组的smart_ptr.

我将重构我的代码,比如使用smart_ptr包装原始数组.这是一个例子:

原始代码:

    class MyList{
    public:
       MyList(int size = 0);
       void Resize(int size);
       ~MyList();
    private:
       int* myArray; 
       int* head_;
       size_t size_;
    }

    MyList::MyList(int size){
        myArray = new int[size]; //allocated memory when object is being created 
        head_ = list_;
        size_ = size;
    }

    void MyList::Resize(int size) {
        if (!list_) {
             delete myArray;
             size_ = 0;
        }
        myArray = new int[size];
        head_ = list_;
        size_ = size;
    }

    MyList::~MyList(){
       delete myArray;
       head …