delete 与 delete[] 区别：

1、针对简单类型 使用 new 分配后的不管是数组还是非数组形式内存空间用两种方式均可 如：

int *a = new int[10];   
delete a;   
delete [] a; 

此种情况中的释放效果相同，原因在于：分配简单类型内存时，内存大小已经确定，系统可以记忆并且进行管理，在析构时，系统并不会调用析构函数， 它直接通过指针可以获取实际分配的内存空间，哪怕是一个数组内存空间(在分配过程中 系统会记录分配内存的大小等信息，此信息保存在结构体_CrtMemBlockHeader中， 具体情况可参看VC安装目录下CRT\SRC\DBGDEL.cpp)

2、针对类Class，两种方式体现出具体差异

当你通过下列方式分配一个类对象数组：

class A
{
    private:
        char *m_cBuffer;
        int m_nLen;
    public:
        A(){ m_cBuffer = new char[m_nLen]; }
        ~A() { delete [] m_cBuffer; }
};
A *a = new A[10];

// 仅释放了a指针指向的全部内存空间 但是只调用了a[0]对象的析构函数 剩下的从a[1]到a[9]这9个用户自行分配的m_cBuffer对应内存空间将不能释放 从而造成内存泄漏
delete a;

// 调用使用类对象的析构函数释放用户自己分配内存空间并且   释放了a指针指向的全部内存空间
delete [] a;

所以总结下就是，如果ptr代表一个用new申请的内存返回的内存空间地址，即所谓的指针，那么：

• delete ptr -- 代表用来释放内存，且只用来释放ptr指向的内存。
• delete[] rg -- 用来释放rg指向的内存，！！还逐一调用数组中每个对象的 destructor！！

对于像 int/char/long/int*/struct 等等简单数据类型，由于对象没有 destructor，所以用 delete 和 delete [] 是一样的！但是如果是C++ 对象数组就不同了！

在 C++11 中，声明一个函数不可以抛出任何异常使用关键字 noexcept。

void mightThrow(); // could throw any exceptions.
void doesNotThrow() noexcept; // does not throw any exceptions.

下面两个函数声明的异常规格在语义上是相同的，都表示函数不抛出任何异常。

void old_stytle() throw();
void new_style() noexcept;

C++ Primer 中关于 what（）的解释：

在之前的例子里，我们使用了一个 throw 表达式以避免把两个代表不同书籍的 Sales_item 相加。我们假设执行 Sales_item 对象加法的代码是与用户交互的代码分离开的。其中与用户交互的代码负责处理发生的异常，它的形式可能如下所示：

while (cin >> item1 >> item2){
  try{
    //执行添加两个Sales_item对象的代码
    //如果添加失败，代码抛出一个runtime_error异常
  } catch (runtime_error err){
      //提醒用户两个ISBN必须一致，询问是否重新输入
      cout << err.what()
           << "\nTry Again? Enter y or n" << endl;
      char c;
      cin >> c;
      İf (!cin || c == 'n')
          break;//跳出while循环
    }
}

程序本来要执行的任务出现在 try 语句块中，是因为这段代码可能会抛出一个 runtime_error 类型的异常。

try 语句块对应一个 catch 子句。该子句负责处理类行为 runtime_error 的异常。如果 try 语句块的代码抛出了runtime_error 异常，接下来执行 catch 块内的语句。在我们书写的 catch 子句中，数出一段提示信息要求用户指定程序是否继续。如果用户输入 n，执行 break 语句并退出 while 循环；否则，直接执行 while 循环的右侧花括号，意味着程序控制权条回到 while 条件部分准备下一次迭代。

给用户的提示信息中输出了 err.what() 的返回值。我们知道 err 的类型是 runtime_error，因此能推断 what 是 runtime_error 类的一个成员函数。每个标准库异常类都定义了名为 what 的成员函数。这些函数没有参数，返回值是 C 风格字符串（即 const char *）其中，runtime_error 的 what 成员函数返回的是初始化一个具体对象所用的 string 对象的副本。如果上一节编写的代码抛出异常，则本节的 catch 子句输出:

Data must refer to same ISBN
Try Again? Enter y or n

const throw() 不是函数，这个东西叫异常规格说明，表示 what 函数可以抛出异常的类型，类型说明放到 () 里，这里面没有类型，就是声明这个函数不抛出异常，通常函数不写后面的就表示函数可以抛出任何类型的异常。

异常规格说明

1、异常规格说明的目的是为了让函数使用者知道该函数可能抛出的异常有哪些。可以在函数的声明中列出这个函数可能抛掷的所有异常类型。例如：

void fun() throw(A，B，C，D);

2、若无异常接口声明，则此函数可以抛掷任何类型的异常。

3、不抛掷任何类型异常的函数声明如下：

#include <iostream>
#include <exception>
using namespace std;

class MyException
{
public:
    MyException(const char *message)
        : message_(message)
    {
        cout << "MyException ..." << endl;
    }
    MyException(const MyException &other) : message_(other.message_)
    {
        cout << "Copy MyException ..." << endl;
    }
    virtual ~MyException()
    {
        cout << "~MyException ..." << endl;
    }

    const char *what() const
    {
        return message_.c_str();
    }
private:
    string message_;
};

class MyExceptionD : public MyException
{
public:
    MyExceptionD(const char *message)
        : MyException(message)
    {
        cout << "MyExceptionD ..." << endl;
    }
    MyExceptionD(const MyExceptionD &other)
        : MyException(other)
    {
        cout << "Copy MyExceptionD ..." << endl;
    }
    ~MyExceptionD()
    {
        cout << "~MyExceptionD ..." << endl;
    }
};

void fun(int n) throw (int, MyException, MyExceptionD)
{
    if (n == 1)
    {
        throw 1;
    }
    else if (n == 2)
    {
        throw MyException("test Exception");
    }
    else if (n == 3)
    {
        throw MyExceptionD("test ExceptionD");
    }

}

void fun2() throw()
{

}

int main(void)
{
    try
    {
        fun(2);
    }

    catch (int n)
    {
        cout << "catch int ..." << endl;
        cout << "n=" << n << endl;
    }
    catch (MyExceptionD &e)
    {
        cout << "catch MyExceptionD ..." << endl;
        cout << e.what() << endl;
    }
    catch (MyException &e)
    {
        cout << "catch MyException ..." << endl;
        cout << e.what() << endl;
    }

    return 0;
}

关于 笔记1 中的复制操作。由于 eof 指示是在读取文件到结尾的时候，才会改变有效的状态。但是，再下一次没有读到数据的时候，eof 才会改变；

但是如果此时还是用 eof 标志位来判断文件是否读到了 end（下图while循环），就会导致此时的 infile>>data 语句还会流入数据（文件的最后一行数据），导致复制的文件中，会多出一行。

while (!infile.eof())
{
    infile >> data;
    cout << data << endl;
    outfile << data << endl;
}

按照 笔记1 中的输入，最后文件 copy 的结果应该是：

copy from test.txt to test_1.txt
John
20
20

为消除多与的读取、复制，我们只需要在还能读取文件数据的时候，才将数据复制到新文件中即可，即代码可以改成：

while (infile >> data)
{
    cout << data << endl;
    outfile << data << endl;
}