标签: delete-operator

关于是否在删除之前进行空检查有几个问题.现在,我仍然在许多生产代码中看到过这样的做法,我不相信所有程序员都不知道这delete 0;是安全的事实.

所以,我不知道是否值得假设之前的null检查delete/free会通过保存函数调用来提供性能优化？

if(0 != p)
  delete p;

我遇到了一个try-catch情况的问题,这里是代码(这很简单):

struct Something
{
  int A, B, C;
  Something()
  {
    A = B = C = 0;
  }
  ~Something()
  {
    cout << "Destructor " << endl;
  }
};

int main()
{
  Something * s = new Something;

  //Something * s = new Something[5];

  try
  {
    delete[] s;
  }
  catch(exception& e)
  {
    delete s;
  }
  return 0;
}

我打算做的是首先尝试将指针删除为数组,如果失败,则进行简单删除.

所以,当我第一次尝试使用'Something'(如在注释行中)的数组时,itr工作得很好.但是,当我现在尝试它时,我得到一个可怕的错误.

有任何想法吗？

我有一个小代码片段用于删除链表中的元素.这是代码:

if (head->data ==  num) {
    delete head;
    head = head->next;
}

你可以向我解释一下为什么这段代码有效.它删除头部并将头部设置为下一个元素.

当我看到这个时,我认为这不起作用,但它有效.

我有

int * array=new int[2];

我想释放最后一个元素的内存，从而将分配的内存减少到只有 1 个元素。我试着打电话

delete array+1;

但它给出了错误

*** 检测到 glibc *** skuska: free(): 无效指针: 0x000000000065a020 *

这可以在没有显式重新分配的情况下在 C++03 中完成吗？

注意：如果我想使用类而不是原始数据类型（如 int），我该如何释放内存以便也调用类的析构函数？

注2：我正在尝试实施 vector::pop_back

我想知道删除是如何工作的？在主要功能我删除了cfact object.但仍然是cfact->Hello()工程,而不是抛出错误.在我发现删除时发现的调试时,cfact释放内存.一旦factory* c2fact = newfun.Newfun("c2_fact");行执行cfact获得一些内存位置.

怎么样？请帮助我理解这个概念..

class factory{

public:
    virtual void Hello() = 0;
};
class c_fact: public factory
{
public:
    void Hello(){
    cout << "class c_fact: public factory"<<endl;
    }
};
class c2_fact: public factory
{
public:
    void Hello(){
    cout << "class c2_fact: public factory"<<endl;
    }
};

class callFun{
public:
    virtual factory* Newfun(string data)
    {
        if(data == "c_fact")
            {return new c_fact;}
        else
            {return new c2_fact;}
    }
};
class newFun:public callFun{ …

这是我记忆的方式.

Expression = new char[MemBlock.length()];
VarArray = new char[Variables.length()];
for (unsigned int i = 0; i < MemBlock.length(); i++)
{
    Expression[i] = MemBlock.at(i);
}
Expression[MemBlock.length() + 1] = NULL;
for (unsigned int i = 0; i < Variables.length(); i++)
{
    VarArray[i] = Variables.at(i);
}
VarArray[Variables.length() + 1] = NULL;

当我尝试删除它时,我收到错误...

Logic::~Logic(){
delete[] VarArray;  -> happens on this line.
VarArray = NULL;
delete[] Expression;
Expression = NULL;
}

在整个代码中,我不会对新阵列进行任何更改,但它告诉我我讨厌一些问题,我不能指出问题所在,任何帮助都会很棒.

我是 C++ 的新手，正在尝试对 shared_ptr (WIP) 进行非常基本的实现。我试图在通过取消引用找到基础值后立即在析构函数中删除堆分配的指针。虽然取消引用发生得很好，但删除 '''ref_count''' 变量会导致问题。有人可以帮忙吗？'''

#include<iostream>

template<typename T>
class shared_ptr{
 private:
  T* native_ptr_ = nullptr;
  int* ref_count_ = nullptr;

  inline void increment_count() {
    *ref_count_++;
  }

  inline void decrement_count() {
    *ref_count_--;
  }

 public:
  shared_ptr() {
    std::cout << "shared_ptr: empty constructor" << std::endl;
    native_ptr_ = nullptr;
    ref_count_ = nullptr;
  }

  shared_ptr(T* ptr) {
    std::cout << "shared_ptr: constructor" << std::endl;
    if (ptr) {
      native_ptr_ = ptr;
      ref_count_ = new int(1);
    }
  }

  ~shared_ptr() {
    std::cout << "shared_ptr: destructor" << std::endl; …

请看看下面的代码::

    #include<iostream>
    using namespace std;
    
    int main()
    {
         int *ptr;
    
        ptr = new int[100000];
    
        cout<<"\n\n address = "<<ptr;

        for(long int i=0;i<100000;i++)
            *(ptr+i) = i+1;
    
        delete []ptr;
        cout<<"\n\n address = "<<ptr;

        ptr = new int[5];
        cout<<"\n\n address = "<<ptr;
        
        return 0;
    }

输出是：

address = 0xd42490

 address = 0xd42490

 address = 0xe919d0

为什么，在delete []ptr;它仍然指向它之前的位置之后（见第二个输出）。

当操作系统本身收回进程的内存时，为什么我们需要显式删除动态分配的内存？在构造函数内部分配动态内存的情况下，为什么我们需要在析构函数中删除它？

我对以下代码有点困惑

int main()
{
    int* a = new int{12};
    int* b = new int;

    b = a;
    delete a;

    delete b;

    return 0;
}

该代码返回一个错误

a.out(27538,0x10ade7e00) malloc: *** error for object 0x7f8c18504160: pointer being freed was not allocated
a.out(27538,0x10ade7e00) malloc: *** set a breakpoint in malloc_error_break to debug
zsh: abort      ./a.out

我的问题是，当我删除 a 时，它会自动删除 b 吗？这里的机制是什么，我有点迷路了。