C++ 如何在c++；

删除双指针会导致程序崩溃等有害影响，程序员应尽量避免这种情况，因为这是不允许的。 但有时如果有人这样做，我想我们该如何处理这件事。 因为C++中的删除是NoT，除了运算符，它不会抛出任何异常。而且它的书面形式也是无效的。那么我们如何捕捉这种异常呢。 下面是代码片段

class myException: public std::runtime_error
{
    public:
        myException(std::string const& msg):
            std::runtime_error(msg)
        {
            cout<<"inside class \n";
            }
};

void main()
{

int* set = new int[100];
cout <<"memory allcated \n";
//use set[]
delete [] set;

cout <<"After delete first \n";
try{
delete [] set;
 throw myException("Error while deleting data \n");
}
catch(std::exception &e)
{
    cout<<"exception \n";
}
catch(...)
{
    cout<<"generic catch \n";
}

cout <<"After delete second \n";

class myException:public std:：runtime\u错误
{
公众：
myException（std:：string const&msg）：
std:：运行时错误（msg）
{
cout考虑到后续的
delete[]
的行为尚未定义，除了编写之外，您什么也做不了

set=nullptr；

在第一次
delete[]
之后。这利用了一个事实，即删除
nullptr
是不可操作的

但实际上，这只会鼓励程序员草率行事。
鉴于后续的
delete[]
的行为尚未定义，除了编写之外，您什么也做不了

set=nullptr；

在第一次
delete[]
之后。这利用了一个事实，即删除
nullptr
是不可操作的

但实际上，这只会鼓励程序员做事马虎。
分段错误、内存访问错误或总线错误不能被异常捕获。程序员需要正确管理自己的内存，因为在C/C++中没有垃圾收集。

但是你在使用C++，为什么不使用RAII？
以下是您应该努力做到的：
内存所有权-明确地通过使用
std:：unique_ptr
或
std:：shared_ptr
和家族
没有对
new
或
delete
的显式原始调用。使用
Make\u unique
或
Make\u shared
或
allocate\u shared
使用诸如
std:：vector
或
std:：array
之类的容器，而不是在堆栈响应上创建动态数组或分配数组
通过valgrind（Memcheck）运行代码，确保代码中没有与内存相关的问题
如果您使用的是
共享\u ptr
，则可以使用
弱\u ptr
访问基础指针，而无需增加引用计数。在这种情况下，如果基础指针已被删除，则会引发
坏\u弱\u ptr
异常。这是我所知的唯一一种为您引发异常的情况访问已删除指针时捕获

在提交之前，代码必须经过多个级别的测试迭代，可能使用不同的工具集。
异常无法捕获分段错误、内存访问错误或总线错误。程序员需要正确管理自己的内存，因为在C/C++中没有垃圾收集。

但是你在使用C++，为什么不使用RAII？
以下是您应该努力做到的：
内存所有权-明确地通过使用
std:：unique_ptr
或
std:：shared_ptr
和家族
没有对
new
或
delete
的显式原始调用。使用
Make\u unique
或
Make\u shared
或
allocate\u shared
使用诸如
std:：vector
或
std:：array
之类的容器，而不是在堆栈响应上创建动态数组或分配数组
通过valgrind（Memcheck）运行代码，确保代码中没有与内存相关的问题
如果您使用的是
共享\u ptr
，则可以使用
弱\u ptr
访问基础指针，而无需增加引用计数。在这种情况下，如果基础指针已被删除，则会引发
坏\u弱\u ptr
异常。这是我所知的唯一一种为您引发异常的情况访问已删除指针时捕获

一个代码必须经过多个层次的测试迭代，也许在提交之前有不同的工具集。
 < P> C++中有一个非常重要的概念，叫做RAII（资源获取是初始化）。
这个概念概括了这样一种思想，即除非对象完全可用且内部一致，否则不可能存在任何对象，并且删除该对象将释放它所拥有的任何资源

因此，在分配内存时，我们使用智能指针：

#include <memory>
#include <iostream>
#include <algorithm>
#include <iterator>

int main()
{
    using namespace std;

    // allocate an array into a smart pointer
    auto set = std::make_unique<int[]>(100);
    cout <<"memory allocated \n";

    //use set[]
    for (int i = 0 ; i < 100 ; ++i) {
      set[i] = i * 2;
    }

    std::copy(&set[0], &set[100] , std::ostream_iterator<int>(cout, ", "));
    cout << std::endl;

    // delete the set
    set.reset();

    cout <<"After delete first \n";

    // delete the set again
    set.reset();
    cout <<"After delete second \n";

   // set also deleted here through RAII
}

#包括
#包括
#包括
#包括
int main（）
{
使用名称空间std；
//将数组分配到智能指针中
自动设置=标准：：使_唯一（100）；
C++中有一个非常重要的概念，叫做RAII（资源获取是初始化）。
这个概念概括了这样一种思想，即除非对象完全可用且内部一致，否则不可能存在任何对象，并且删除该对象将释放它所拥有的任何资源

因此，在分配内存时，我们使用智能指针：

#include <memory>
#include <iostream>
#include <algorithm>
#include <iterator>

int main()
{
    using namespace std;

    // allocate an array into a smart pointer
    auto set = std::make_unique<int[]>(100);
    cout <<"memory allocated \n";

    //use set[]
    for (int i = 0 ; i < 100 ; ++i) {
      set[i] = i * 2;
    }

    std::copy(&set[0], &set[100] , std::ostream_iterator<int>(cout, ", "));
    cout << std::endl;

    // delete the set
    set.reset();

    cout <<"After delete first \n";

    // delete the set again
    set.reset();
    cout <<"After delete second \n";

   // set also deleted here through RAII
}

#包括
#包括
#包括
#包括
int main（）
{
使用名称空间std；
//将数组分配到智能指针中
自动设置=标准：：使_唯一（100）；
cout我在这里添加了另一个答案，因为之前的答案非常注重手动管理内存，而正确的答案是避免首先处理内存

void main() {
    std::vector<int> set (100);
    cout << "memory allocated\n";
    //use set
}

void main（）{
std：：向量集（100）；
cout我在这里添加了另一个答案，因为之前的答案非常注重手动管理内存，而正确的答案是避免首先处理内存

void main() {
    std::vector<int> set (100);
    cout << "memory allocated\n";
    //use set
}

void main（）{
std：：向量集（100）；
CUT使用一个<代码> STD:：向量< /代码>？在C++语言中，你没有什么可以处理双重删除。它是未定义的行为；标准“不要求”。如果你重复删除，你的代码可能崩溃（不是例外），格式化硬盘。