c++中的异常处理

 目录

　　1、 异常 与 Bug 的区别

　　2、c++中的异常处理方式（try ... catch ...）

　　3、自定义异常类的使用方式

　　4、C++ 标准库中的异常类

　　5、try..catch 另类写法 和  函数异常声明/定义 throw()

1、 异常 与 Bug 的区别　　

　　“异常”是我们在程序开发中必须考虑的一些特殊情况，是程序运行时就可预料的执行分支（注：异常是不可避免的，如程序运行时产生除 0 的情况；打开的外部文件不存在；数组访问的越界等等）；

　　“Bug”是程序的缺陷，是程序运行时不被预期的运行方式（注：Bug是人为的、可避免的；如使用野指针；堆数组使用结束后未释放等等）；

　　无论是“异常”还是“Bug”，都是程序正常运行过程中可能出现的意外情况。区别是“异常”可以捕获，并做出合适的处理，“Bug"所带来的后果是无法预测的，需要重写相应的代码。

2、c++中的异常处理方式（try ... catch ...）

　（1）基本语法

// 异常基本语法
try
{
    // 可能产生异常的代码，若发生异常，通过 throw 关键字抛出异常
}
catch(异常类型) // 异常捕获，注（...）代表捕获所有异常
{
    // 处理异常的代码，该异常由try语句块产生
}

　（2）基本规则　

　　1）同一个 try 语句可以跟上多个 catch 语句（在工程中，将可能产生异常的代码放在 try 语句块中，然后后面跟上多个 catch 语句）；

　　2）try 语句中通过 throw 关键字 可以抛出任何类型的异常（int、字符串、对象等等）；　

　　3）catch 语句可以定义具体处理的异常类型，如 catch( int ) 只捕获 int 类型异常, 但无法进一步获取异常信息；catch( int a ) 只捕获 int 类型异常，可以进一步获取异常信息；

　　4）不同类型的异常由不同的 catch 语句负责处理；

　　5）catch(...) 用于处理所有类型的异常（只能放在所有 catch语句 的后面）；

　　6）任何异常都只能被捕获（catch）一次；

　　7）只要被 catch 捕获一次，其它的 catch 就没有捕获机会了；

　　8）throw 抛出异常的类型 与 catch 捕获异常的类型  必须严格匹配（不能进行类型转换）；若匹配成功，则能够捕获该异常；否则捕获失败，程序停止执行。

　　　　

　　其实，为了更好的理解 异常抛出 和 异常捕获 这两个动作，我们可以将其想象成 函数调用，抛出异常好比是函数中实参，捕获异常好比是函数中形参，只有当实参的类型 与 形参的类型严格匹配时，这次捕获才能成功。为什么说想象成函数调用，而不是正真的函数调用呢？原因就是：函数调用时，用实参初始化形参时可以进行隐式的类型转换；但是在异常捕获时，必须严格匹配异常类型。　　

（3）异常抛出（throw exception）的逻辑分析

　　情况1：异常代码没有放到  try{ }  语句中，这也意味着没有对应的 catch 语句，其实就是普通函数调用，若此时抛出异常（throw），则程序停止执行；

　　情况2：异常代码放到  try{ throw exception... }  语句中，这也意味着有对应的 catch 语句，则抛出异常时就会与 catch语句严格匹配；若匹配成功，则可以捕获该异常，否则不能捕获该异常，程序停止执行。

　　throw 抛出异常后，在发生异常的函数中至上而下的严格匹配每一个 catch 语句捕获的异常类型，来判断是否能够捕获该异常；

　　　1） 若发生异常的函数中  能够捕获该异常，则程序接着往下执行；

　　　2） 若发生异常的函数中  不能捕获该异常，则未被处理的异常会顺着函数调用栈向上传播，直到该异常被捕获为止，否则程序将停止执行；

　　总结：throw 抛出的异常必须被 对应的 catch 捕获，否则程序将停止执行；

　　　　

　　通过上图来说明异常抛出后的执行顺序：

　　1）在 函数 function3 中 抛出异常 throw 1；但是在 function3 中并不能捕获该异常，则异常继续向外层函数 function2 抛出

　　2）在 函数 function2 中，异常依旧没有被捕获，则异常继续向外层函数 function1 抛出；

　　3）在 函数 function1 中，异常被 catch 捕获和处理，然后程序继续向下执行；

　　　　注：若在 函数 function1 中，异常还是没有被捕获，则异常会一直向外层函数抛出，直到该异常被捕获为止，否在程序停止执行。 

　　代码展示：

#include <iostream>
#include <string>

using namespace std;

double divide(double a, double b)
{
    const double delta = 0.000000001;
    double ret = 0;

    if( !((-delta < b) && (b < delta)) )
    {
        ret = a / b;
    }
    else
    {
        throw "Divided by zero..."; 
    }

    cout << "divide(double a, double b)" << endl;
     
    return ret;
}

double ExceptionFunc()
{
    double d = divide(2, 0);
    
    cout << "ExceptionFunc()" << endl;
    
    return d;
}

int main(int argc, char *argv[])
{      
    double d = ExceptionFunc();
    
    cout << "result = " << d << endl;

    return 0;
}

/**
 * 运行结果：
 * terminate called after throwing an instance of 'char const*'
 * Aborted (core dumped)
 */
 
/**
 * 分析：
 * throw "Divided by zero..."; 抛出异常后，divide(double a, double b) 函数不能捕获该异常，则异常继续抛给 ExceptionFunc()；
 * 在 ExceptionFunc() 中，也不能捕获该异常，则异常继续抛给 main()；
 * 在 main()中，也不能捕获该异常，则程序停止执行。
 */

  

#include <iostream>
#include <string>

using namespace std;

double divide(double a, double b)
{
    const double delta = 0.000000001;
    double ret = 0;
    
    try
    {
        if( !((-delta < b) && (b < delta)) )
        {
            ret = a / b;
        }
        else
        {
            throw "Divided by zero..."; 
        }
    }
    catch(char const* s)  
    {
        cout << s << endl;
    } 
        
    cout << "divide(double a, double b)" << endl;
 
    return ret;
}

double ExceptionFunc()
{   
    double d = divide(2, 0);
    
    cout << "ExceptionFunc()" << endl;
    
    return d;
}

int main(int argc, char *argv[])
{ 
    ExceptionFunc();
      
    cout << "test end!" << endl;

    return 0;
}

/**
 * 运行结果：
 * Divided by zero...
 * divide(double a, double b)
 * ExceptionFunc()
 * test end!
 */
 
/**
 * 分析：
 * throw "Divided by zero..."; 抛出异常后，在divide(double a, double b) 中，异常被捕获，则程序继续向下执行;
 *  catch(char const* s)    // throw "Divided by zero..."
 *  {
 *     cout << s << endl;
 *  }   
 *  cout << "divide(double a, double b)" << endl;
 *
 *  divide(2, 0); 函数调用结束，返回到 ExceptionFunc() 中，
 *  cout << "ExceptionFunc()" << endl;  
 *   
 *  ExceptionFunc()调用结束，返回 main()中，继续向下执行；
 *  cout << "test end!" << endl;
 */

#include <iostream>
#include <string>

using namespace std;

double divide(double a, double b)
{
    const double delta = 0.000000001;
    double ret = 0;
          
    if( !((-delta < b) && (b < delta)) )
    {
        ret = a / b;
    }
    else
    {
        throw "Divided by zero..."; 
    }

    cout << "divide(double a, double b)" << endl;

    return ret;
}

double ExceptionFunc()
{
    double d;
    
    try
    {
        d = divide(2, 0);
            
        cout << "d = " << d << endl;
    }
    catch(char const* s)
    {
        cout << s << endl;
    }           
    
    cout << "ExceptionFunc()" << endl;
    
    return d;
}

int main(int argc, char *argv[])
{ 
    ExceptionFunc();
    
    cout << "test end!" << endl;

    return 0;
}

/**
 * 运行结果：
 * Divided by zero...
 * ExceptionFunc()
 * test end!
 */
 
/**
 * 分析：
 * throw "Divided by zero..."; 抛出异常后，divide(double a, double b) 函数不能捕获该异常，则异常继续抛给 ExceptionFunc()；
 * 在 ExceptionFunc() 中，异常被捕获，则程序继续向下执行;
 *  catch(char const* s)    // throw "Divided by zero..."
 *  {
 *     cout << s << endl;
 *  }   
 *  cout << "ExceptionFunc()" << endl;     
 *  ExceptionFunc()调用结束，返回 main()中，继续向下执行；
 *  cout << "test end!" << endl;
 */

#include <iostream>
#include <string>

using namespace std;

double divide(double a, double b)
{
    const double delta = 0.000000001;
    double ret = 0;

    if( !((-delta < b) && (b < delta)) )
    {
        ret = a / b;
    }
    else
    {
        throw "Divided by zero..."; 
    }
 
    cout << "divide(double a, double b)" << endl;

    return ret;
}

double ExceptionFunc()
{
    double d = divide(2, 0);
    
    cout << "ExceptionFunc()" << endl;
    
    return d;
}

int main(int argc, char *argv[])
{ 
    try
    {
        double d = ExceptionFunc();
            
        cout << "d = " << d << endl;
    }
    catch(char const* s)
    {
        cout << s << endl;
    }        
    
    cout << "test end!" << endl;

    return 0;
}

/**
 * 运行结果：
 * Divided by zero...
 * test end!
 */
 
/**
 * 分析：
 * throw "Divided by zero..."; 抛出异常后，divide(double a, double b) 函数不能捕获该异常，则异常继续抛给 ExceptionFunc()；
 * 在 ExceptionFunc() 中，也不能捕获该异常，则异常继续抛给 main()；
 * 在 main()中，异常与被捕获，则程序继续向下执行
 *  catch(char const* s)    // throw "Divided by zero..."
 *  {
 *     cout << s << endl;
 *  }   
 *  cout << "test end!" << endl;     
 */

#include <iostream>
#include <string>

using namespace std;

void Demo1()
{
    try
    {   
        throw 2.0;
    }
    catch(char c)
    {
        cout << "catch(char c)" << endl;
    }
    catch(short c)
    {
        cout << "catch(short c)" << endl;
    }
    catch(double c)   // throw 2.0;
    {
        cout << "catch(double c)" << endl;
    }
    catch(...)   // 表示捕获任意类型的异常
    {
        cout << "catch(...)" << endl;
    }   
}

void Demo2()
{
    throw string("D.T.Software"); 
}

int main(int argc, char *argv[])
{    
    Demo1();
    
    try
    {
        Demo2();      
    }
    catch(char* s)
    {
        cout << "catch(char *s)" << endl;
    }
    catch(const char* cs)
    {
        cout << "catch(const char *cs)" << endl;
    }
    catch(string ss)    // throw string("D.T.Software"); 
    {
        cout << "catch(string ss)" << endl;
    }  
    
    return 0;
}
/**
 * 运行结果：
 * catch(double c)
 * catch(string ss)
 */

// 结论：异常类型严格匹配，（...）表示捕获任意类型的异常

 　　总结：

　　情况1：只抛出异常，没有对应地异常捕获；（  没有 try ... catch ... 结构  ）

　　情况2：在try语句块中抛出异常（直接在try语句块中使用 throw 抛出异常；或者try语句块中放入有异常的函数，间接地在函数中使用 throw 抛出异常），然后通过catch语句捕获同类型的异常并进行异常处理；（ 现象： 一个 try ... catch ... 结构 ）

　　那么现在我们考虑能不能在情况2的基础上，将捕获到异常继续抛出呢？（在 catch 语句块中重新抛出异常？）

　　可以在 catch 语句中重新抛出异常，此时需要外层的 try ... catch ...捕获这个异常；

　　注：catch 语句中只抛出异常，什么也不做；当捕获任意类型的异常时，直接使用 throw 就行。

　　

#include <iostream>
#include <string>

using namespace std;

void Demo()
{
    try
    {
        throw 'c';
    }
    catch(int i)
    {
        cout << "Inner: catch(int i)" << endl;
        throw i;
    }
    catch(...)
    {
        cout << "Inner: catch(...)" << endl;
        throw;
    }
}

int main(int argc, char *argv[])
{
    Demo();
    
    return 0;
}

/**
 * 运行结果：
 * Inner: catch(...)
 * terminate called after throwing an instance of 'char'
 * Aborted (core dumped)
 */
 // 错误原因：异常重解释之后，没有被捕获

#include <iostream>
#include <string>

using namespace std;

void Demo()
{
    try
    {
        try
        {
            throw 'c';
        }
        catch(int i)
        {
            cout << "Inner: catch(int i)" << endl;
            throw i;
        }
        catch(...)
        {
            cout << "Inner: catch(...)" << endl;
            throw;
        }
    }
    catch(...)
    {
        cout << "Outer: catch(...)" << endl;
    }
}

int main(int argc, char *argv[])
{
    Demo();
    
    return 0;
}
/**
 * 运行结果：
 * Inner: catch(...)
 * Outer: catch(...)
 */

 　　为什么要在 catch 语句块中重新抛出异常？

　　在工程中，利用在 catch 语句块中重新解释异常并抛出这一特性，可以统一异常类型。（很晦涩，看下面解释....）

　　

　　我们通过上图来详细说明这个情况：

　　背景介绍：出于开发效率考虑，在工程开发中一般会基于第三方库来开发，但是，第三方库中的某些功能并不完善（可读性差），此时就需要封装第三方库中的这个功能。

　　在上图中，由于第三方库中 func()函数的异常类型是 int 类型，可读性很差，不能够直接通过异常结果知道该异常所代表的意思；基于这种情况，我们通过私有库中的 MyFunc()函数对第三方库中func()进行了封装，使得 MyFunc()函数中的异常类型可以显示更多的异常信息（MyFunc() 函数中的异常类型是自定义类型，可以是字符串、类类型等等），增强代码的可读性；为了将 func()中的异常类型 和 MyFunc() 中异常类型统一起来，我们可以在私有库中的MyFunc() 函数中去捕获第三方库中的 func() 函数抛出的异常，然后根据捕获到的异常重新解释为我们想要的异常，这样我们工程开发中所面对的异常类型就是一致的；接下来我们用代码复现这个场景：

#include <iostream>
#include <string>

using namespace std;

/*
    假设：当前的函数是第三方库中的函数，因此，我们无法修改源代码
    
    函数名： void func(int i)
    抛出异常的类型： int
                        -1 ==》 参数异常
                        -2 ==》 运行异常
                        -3 ==》 超时异常
*/
void func(int i)
{
    if( i < 0 )
    {
        throw -1;
    }
    
    if( i > 100 )
    {
        throw -2;
    }
    
    if( i == 11 )
    {
        throw -3;
    }
    
    cout << "Run func..." << endl;
}

int main(int argc, char *argv[])
{
    try
    {
        func(11);
    }
    catch(int i)
    {
        cout << "Exception Info: " << i << endl;
    }
    
    return 0;
}

/**
 * 运行结果：
 * Exception Info: -3
 */
 
// 异常显示结果太简单，当发生异常时，需要查询技术文档才能知道这儿的-3代表的意思，可读性很差

// 异常的重解释，在 catch 语句中重新抛出异常

#include <iostream>
#include <string>

using namespace std;

/*
    假设： 当前的函数式第三方库中的函数，因此，我们无法修改源代码
    
    函数名： void func(int i)
    抛出异常的类型： int
                        -1 ==》 参数异常
                        -2 ==》 运行异常
                        -3 ==》 超时异常
*/
void func(int i)
{
    if( i < 0 )
    {
        throw -1;
    }
    
    if( i > 100 )
    {
        throw -2;
    }
    
    if( i == 11 )
    {
        throw -3;
    }
    
    cout << "Run func..." << endl;
}

/* 不能修改 func() 函数，则我们定义 MyFunc() 函数重解释 func() 的异常 */
void MyFunc(int i)
{
    try
    {
        func(i);
    }
    catch(int i)
    {
        switch(i)
        {
            case -1:
                throw "Invalid Parameter";   // 可以抛出更详细的数据，如类对象，后续讲解
                break;
            case -2:
                throw "Runtime Exception";
                break;
            case -3:
                throw "Timeout Exception";
                break;
        }
    }
}

int main(int argc, char *argv[])
{
    try
    {
        MyFunc(11);
    }
    catch(const char* cs)
    {
        cout << "Exception Info: " << cs << endl;
    }
    
    return 0;
}
/**
 * 运行结果：
 * Exception Info: Timeout Exception
 */

 3、自定义异常类的使用方式

　　（1）异常的类型可以是自定义类类型；

　　（2）对于类类型异常的匹配依旧是自上而下严格匹配；

　　（3）赋值兼容性原则在异常匹配中依然适用；（注：在赋值兼容性中，子类是特殊的父类，父类可以捕获子类的异常；同样满足异常类型严格匹配的原则）

   　（4）在赋值兼容性原则中，一般将

　　　　1）匹配子类异常的 catch 放在上部；

　　　　2）匹配父类异常的 catch 放在下部；

　　（5）在定义 catch 语句块时，推荐使用 const 引用作为参数，提高程序的运行效率；

#include <iostream>
#include <string>

using namespace std;

class Base
{
};

/* 定义异常类 */
class Exception : public Base
{
    int m_id;
    string m_desc;
public:
    Exception(int id, string desc)
    {
        m_id = id;
        m_desc = desc;
    }
    
    int id() const
    {
        return m_id;
    }
    
    string description() const
    {
        return m_desc;
    }
};

/*
    假设： 当前的函数式第三方库中的函数，因此，我们无法修改源代码
    函数名： void func(int i)
    抛出异常的类型： int
                        -1 ==》 参数异常
                        -2 ==》 运行异常
                        -3 ==》 超时异常
*/

void func(int i)
{
    if( i < 0 )
    {
        throw -1;
    }
    
    if( i > 100 )
    {
        throw -2;
    }
    
    if( i == 11 )
    {
        throw -3;
    }
    
    cout << "Run func..." << endl;
}

/* 使用自定义的类类型来优化 */
void MyFunc(int i)
{
    try
    {
        func(i);
    }
    catch(int i)
    {
        switch(i)
        {
            case -1:
                throw Exception(-1, "Invalid Parameter");  // 直接调用构造函数生成异常对象；
                break;
            case -2:
                throw Exception(-2, "Runtime Exception");
                break;
            case -3:
                throw Exception(-3, "Timeout Exception");
                break;
        }
    }
}

int main(int argc, char *argv[])
{
    try
    {
        MyFunc(11);
    }
    catch(const Exception& e)  // 1 使用 const 引用类型作为参数  2 赋值兼容性原则（参考第4点）
    {
        cout << "Exception Info: " << endl;
        cout << "   ID: " << e.id() << endl;
        cout << "   Description: " << e.description() << endl;
    }
    catch(const Base& e) 
    {
        cout << "catch(const Base& e)" << endl;
    }
    
    return 0;
}
/**
 * 运行结果：
 * Exception Info：
 * ID： -3
 * Description: Timeout Exception
 */

4、C++ 标准库中的异常类

　　（1）C++ 标准库中提供了实用异常类族；

　　（2）标准库中的异常都是从 exception 类派生的；

　　（3）exception 类有两个主要的分支：

　　　　1）logic_error

       　　2）runtime_error

    　（4）标准库中的异常类继承图：

　　　　

#include <iostream>
#include <string>
#include <stdexcept> 
#include <sstream>

using namespace std;

/*
    __FILE__  __FUNCTION__  const char[]
    __LINE__  int
*/

template
<typename T, int N>
class Array
{
private:
    T arr[N];
public:
    Array();
    T& operator[] (int index);
    void print() const;
};

template
<typename T, int N>
Array<T, N>::Array()
{
    for(int i = 0; i < N; i++)
    {
        arr[i] = 0;
    }
}

template
<typename T, int N>
T& Array<T, N>::operator[] (int index)
{
    if( (0 <= index) && (index < N) )
    {
        return arr[index];
    }
    else
    {
        ostringstream oss;
        
        throw out_of_range(string(__FILE__) + ":" + static_cast<ostringstream&>(oss << __LINE__).str() + ":" + __FUNCTION__

                        + "	 >> exception: the index of array is out of range");  
    }
}

template
<typename T, int N>

void Array<T, N>::print() const
{
    for(int i = 0; i < N; i++)
    {
        cout << arr[i] << " ";
    }
    cout << endl;
}

int main(int argc, char *argv[])
{
    try
    {
        Array<int, 5> arr;

        arr.print();
        arr[-1] = 1;    // 异常测试
        arr.print();
    }

    catch(const out_of_range& e)  // 1 使用 const 引用类型作为参数  2 赋值兼容性原则（参考第4点）
    {
        cout << e.what() << endl;
    }

    catch(...)
    {
        cout << "other exception ... " << endl;
    }

    return 0;
}

/**
 * 运行结果：
 * 0 0 0 0 0
 * test.cpp:47:operator[]     >> exception: the index of array is out of range
 */

// 模板文件 Array.hpp 的优化
#ifndef ARRAY_H
#define ARRAY_H

#include <stdexcept>  // 标准库中的异常类头文件；

using namespace std;A

template
< typename T, int N >
class Array
{
    T m_array[N];
public:
    int length() const;
    bool set(int index, T value);
    bool get(int index, T& value);
    T& operator[] (int index);
    T operator[] (int index) const;
    virtual ~Array();
};

template
< typename T, int N >
int Array<T, N>::length() const
{
    return N;
}

template
< typename T, int N >
bool Array<T, N>::set(int index, T value)
{
    bool ret = (0 <= index) && (index < N);
    
    if( ret )
    {
        m_array[index] = value;
    }
    
    return ret;
}

template
< typename T, int N >
bool Array<T, N>::get(int index, T& value)
{
    bool ret = (0 <= index) && (index < N);
    
    if( ret )
    {
        value = m_array[index];
    }
    
    return ret;
}

template
< typename T, int N >
T& Array<T, N>::operator[] (int index)
{
    if( (0 <= index) && (index < N) )
    {
        return m_array[index];  // 这里之前没有验证 index 是否合法，因为验证了也没办法处理；
    }
    else
    {
        throw out_of_range("T& Array<T, N>::operator[] (int index)");
    }
}

template
< typename T, int N >
T Array<T, N>::operator[] (int index) const
{
    if( (0 <= index) && (index < N) )
    {
        return m_array[index];  // 这里之前没有验证 index 是否合法，因为验证了也没办法处理；
    }
    else
    {
        throw out_of_range("T Array<T, N>::operator[] (int index) const");
    }
}

template
< typename T, int N >
Array<T, N>::~Array()
{

}

#endif

//------------------------------------------------------------------

// 模板文件 HeapArray.hpp 的优化

#ifndef HEAPARRAY_H
#define HEAPARRAY_H

#include <stdexcept>  // 添加标准头文件；

using namespace std;

template
< typename T >
class HeapArray
{
private:
    int m_length;
    T* m_pointer;
    
    HeapArray(int len);
    HeapArray(const HeapArray<T>& obj);
    bool construct();
public:
    static HeapArray<T>* NewInstance(int length); 
    int length() const;
    bool get(int index, T& value);
    bool set(int index ,T value);
    T& operator [] (int index);
    T operator [] (int index) const;
    HeapArray<T>& self();
    const HeapArray<T>& self() const;  // 要考虑成员函数有没有必要成为 const 函数，const 函数主要是给 cosnt 对象调用；
    ~HeapArray();
};

template
< typename T >
HeapArray<T>::HeapArray(int len)
{
    m_length = len;
}

template
< typename T >
bool HeapArray<T>::construct()
{   
    m_pointer = new T[m_length];
    
    return m_pointer != NULL;
}

template
< typename T >
HeapArray<T>* HeapArray<T>::NewInstance(int length) 
{
    HeapArray<T>* ret = new HeapArray<T>(length);
    
    if( !(ret && ret->construct()) ) 
    {
        delete ret;
        ret = 0;
    }
        
    return ret;
}

template
< typename T >
int HeapArray<T>::length() const
{
    return m_length;
}

template
< typename T >
bool HeapArray<T>::get(int index, T& value)
{
    bool ret = (0 <= index) && (index < length());
    
    if( ret )
    {
        value = m_pointer[index];
    }
    
    return ret;
}

template
< typename T >
bool HeapArray<T>::set(int index, T value)
{
    bool ret = (0 <= index) && (index < length());
    
    if( ret )
    {
        m_pointer[index] = value;
    }
    
    return ret;
}

template
< typename T >
T& HeapArray<T>::operator [] (int index)
{
    if( (0 <= index) && (index < length()) )
    {
        return m_pointer[index];  // 优化这里，越界抛异常；
    }
    else
    {
        throw out_of_range("T& HeapArray<T>::operator [] (int index)");
    }
}

template
< typename T >
T HeapArray<T>::operator [] (int index) const
{
    if( (0 <= index) && (index < length()) )
    {
        return m_pointer[index];  // 优化这里，越界抛异常；
    }
    else
    {
        throw out_of_range("T HeapArray<T>::operator [] (int index) const");
    }
}

template
< typename T >
HeapArray<T>& HeapArray<T>::self()
{
    return *this;
}

template
< typename T >
const HeapArray<T>& HeapArray<T>::self() const
{
    return *this;
}

template
< typename T >
HeapArray<T>::~HeapArray()
{
    delete[]m_pointer;
}

#endif

//------------------------------------------------------------------

// 测试文件 main.cpp 

#include <iostream>
#include <string>
#include <memory>  //for auto_ptr
#include "Array.hpp"
#include "HeapArray.hpp"

using namespace std;

void TestArray()
{
    Array<int, 5> a;
    
    for(int i=0; i<a.length(); i++)
    {
        a[i] = i;   
    }
    
    for (int i=0; i<a.length(); i++)
    {
        cout << a[i] << ", ";
    }
    cout << endl;
}

void TestHeapArray()
{
    //使用智能指针，目的是自动释放堆空间
    auto_ptr< HeapArray<double> > pa(HeapArray<double>::NewInstance(5));
    
    if(pa.get() != NULL)
    {
        HeapArray<double>& array = pa->self();
        
        for(int i=0; i<array.length(); i++)
        {
            array[i] = i;
        }
        
        for (int i=0; i<array.length(); i++)
        {
             cout << array[i] << ", ";
        }
        cout << endl;         
    }         
}

int main(int argc, char *argv[])
{
    try
    {
        TestArray();

        cout << endl;     

        TestHeapArray();
    }
    catch(const out_of_range& e)
    {
        cout << "exception: " << e.what() << endl;
    }
    catch(...)
    {
        cout << "other exception ... " << endl;
    }   

    return 0;
}

/**
 * 运新结果：
 * 0, 1, 2, 3, 4, 
 * ---------------------
 * 0, 1, 2, 3, 4, 
 * Run End...
 */

/**
 * 栈空间数组下标越界异常运行结果：
 * exception: T& Array<T, N>::operator[] (int index)
 * Run End...
 */

/**
 * 堆空间数组下标越界异常运行结果：
 * 0, 1, 2, 3, 4, 
 * ---------------------
 * exception: T& HeapArray<T>::operator [] (int index)
 * Run End...
 */

5、try..catch 另类写法 和  函数异常声明/定义 throw()

 　　try..catch 另类写法(不建议使用)的特点：

　　（1）try-catch用于分隔正常功能代码与异常处理代码

　　（2）try-catch可以直接将函数实现分隔为2部分

　　函数异常声明/定义的特点：

　　（1）函数声明和定义时可以直接指定可能抛出的异常类型；

　　（2）异常声明成为函数的一部分，可以提高代码可读性；

　　（3）函数异常声明是一种与编译器之间的契约；

　　（4）函数声明异常后就只能抛出声明的异常；

　　　　A、抛出其它异常将导致程序运行终止；

　　　　B、可以直接通过异常声明定义无异常函数；

#include <iostream>
#include <string>

using namespace std;

// int func(int i, int j) throw()  // 无异常函数声明

int func(int i, int j) throw(int, char)  //异常声明，表示该函数可能抛出int和char两种类型的异常
{
    if ((0 < j) && (j < 10))
    {
        return (i + j);
    } 
    else
    {
        throw 'c'; // 只能抛出指定的异常类型（int、char），否则程序运行失败
    }
}

//以下的写法已经不被推荐  !!!
void test(int i) try   //正常代码
{
    cout << "func(i, i) = " << func(i, i) << endl;
}
catch (int j)   //异常代码
{
    cout << "Exception: " << j << endl;
}
catch (char j)   //异常代码
{
    cout << "Exception: " << j << endl;
}

int main(int argc, char *argv[])
{
    test(5); //正常

    test(10); //抛异常

    return 0;
}
/**
 * 运行结果：
 * func(i, i) = 10
 * Exception: c
 */