C++ 何时删除try catch块中的指针

快速最佳实践问题（注意，我不允许在此代码中使用任何智能指针）。我的印象是，如果我传递一个指向某个函数的指针，并且发生了异常情况，那么如果在被调用函数或第一次分配内存的函数中从未删除过内存，那么内存就会泄漏。删除catch块中的内存安全吗？还是应该删除调用函数中的内存

例如：

int main() {
  object* myPtr = new object(); //dynamic memory on heap
  foo(*myPtr);  //pass pointer to function foo

  return 0;
}

void foo(object &pointer) {
  try {
    /* do stuff here
    with the pointer */
  }
  catch (const char &e) {
    cout<< "An error occured: " << e << endl;
  }
  catch (...)
    cout<< "Caught unknown exception." << endl;
  }
}

还是在试抓区

void foo(object &pointer) {
      try {
        /* do stuff here
        with the pointer */
      }
      catch (const char &e) {
        cout<< "An error occured: " << e << endl;
        delete &pointer;
      }
      catch (...)
        cout<< "Caught unknown exception." << endl;
        delete &pointer;
      }
    }

void foo（对象和指针）{
试一试{
/*在这里做事
用指针*/
}
捕获（常量字符和e）{
库特
何时删除try catch块中的指针

不要

在调用
foo
之后，在
main
中删除它

简而言之，把它从你创建它的地方删除。其他任何东西都会造成混乱的不对称


我的印象是，如果我传递一个指向某个函数的指针，并且发生了异常情况，那么如果从未删除，内存就会泄漏

不知道你从哪里听到的。算了吧。这是胡说八道


删除catch块中的内存安全吗？还是应该删除调用函数中的内存

你可以：

删除
try
末尾和两个
catch
块中的内存
删除结束后的内存
try
/
catch
链
两者都是完全“安全”的

但是，就像我说的-


我应该在函数返回后删除指针吗

对，没错


顺便提一下
您缺少一个
*
和一个大写输入错误：

object* myPtr = new object();
//    ^             ^

事实上，带有智能指针的版本可能如下所示：

#include <iostream>
#include <memory>

struct object {};

void foo(object& obj)
{
   try {
      // do stuff here with the reference (not a pointer)
   }
   catch (const char* e) {
      std::cout << "An error occured: " << e << std::endl;
   }
   catch (...)
      std::cout << "Caught unknown exception." << std::endl;
   }
}

int main()
{
   auto myPtr = std::make_unique<object>();
   foo(*myPtr);
}

#包括
#包括
结构对象{}；
void foo（对象和对象）
{
试一试{
//使用引用（而不是指针）在此处执行操作
}
捕获（常量字符*e）{
标准：：cout
何时删除try catch块中的指针

不要

在调用
foo
之后，在
main
中删除它

简而言之，把它从你创建它的地方删除。其他任何东西都会造成混乱的不对称


我的印象是，如果我传递一个指向某个函数的指针，并且发生了异常情况，那么如果从未删除，内存就会泄漏

不知道你从哪里听到的。算了吧。这是胡说八道


删除catch块中的内存安全吗？还是应该删除调用函数中的内存

你可以：

删除
try
末尾和两个
catch
块中的内存
删除结束后的内存
try
/
catch
链
两者都是完全“安全”的

但是，就像我说的-


我应该在函数返回后删除指针吗

对，没错


顺便提一下
您缺少一个
*
和一个大写输入错误：

object* myPtr = new object();
//    ^             ^

事实上，带有智能指针的版本可能如下所示：

#include <iostream>
#include <memory>

struct object {};

void foo(object& obj)
{
   try {
      // do stuff here with the reference (not a pointer)
   }
   catch (const char* e) {
      std::cout << "An error occured: " << e << std::endl;
   }
   catch (...)
      std::cout << "Caught unknown exception." << std::endl;
   }
}

int main()
{
   auto myPtr = std::make_unique<object>();
   foo(*myPtr);
}

#包括
#包括
结构对象{}；
void foo（对象和对象）
{
试一试{
//使用引用（而不是指针）在此处执行操作
}
捕获（常量字符*e）{
标准：：cout
我的印象是，如果我传递一个指向某个函数的指针，并且发生了异常情况，那么如果在被调用函数或第一次分配内存的函数中从未删除过内存，那么内存就会泄漏

不要求在分配内存的同一个函数中释放内存。但是，通常情况下，如果指针指向分配了
new
的内存，则如果从未对其调用
delete
，则无论实际调用的位置如何，它都会泄漏

删除catch块中的内存安全吗？还是应该删除调用函数中的内存

在您的示例中，
foo（）
没有如何分配
对象的概念，因此不，在
foo（）
内部调用
delete
是不安全的

例如，您可以使用其中一个来调用
foo（）
，如果
foo（）
调用
delete
，所有这些都会出现问题：

int main() {
    object myObj;
    foo(myObj);
    return 0;
}


intmain（）{
std:：unique_ptr myPtr（新对象）；
foo（*myPtr）；
返回0；
}


intmain（）{
向量缓冲区（sizeof（object））；
object*myPtr=new（&buffer[0]）对象；
foo（*myPtr）；
myPtr->~object（）；
返回0；
}

从
foo
的角度来看，如何分配
对象
并不重要，只要它是进入
foo（）
的有效
对象
实例。因为
main（）
决定了
对象
的分配方式，
main（）
应该是决定如何正确释放它的人，如果有的话

我的印象是，如果我传递一个指向某个函数的指针，并且发生了异常情况，那么如果在被调用函数或第一次分配内存的函数中从未删除过内存，那么内存就会泄漏

不要求在分配内存的同一个函数中释放内存。但是，通常情况下，如果指针指向分配了
new
的内存，则如果从未对其调用
delete
，则无论实际调用的位置如何，它都会泄漏

删除catch块中的内存安全吗？还是应该删除调用函数中的内存

在您的示例中，
foo（）
没有如何分配
对象的概念，因此不，在
foo（）
内部调用
delete
是不安全的

例如，您可以使用其中一个来调用
foo（）
，如果
foo（）
调用
delete
，所有这些都会出现问题：

int main() {
    object myObj;
    foo(myObj);
    return 0;
}


intmain（）{
std:：unique_ptr myPtr（新对象）；
foo（*myPtr）；
返回0；
}