在构造和析构中抛出异常

测试验证在类构造和析构中抛出异常, 是否会调用该类析构.

如果在一个类成员函数中抛异常, 可以进入该类的析构函数.

/// @file ClassroomExamples.cpp
/// @brief xxxx-xxxx课堂笔记的验证代码
/// 测试c++异常
/// 在构造和析构中抛出异常

#include <iostream>
#include <limits>
#include "MyException.h"
#include "TestThrow.h"

using namespace std;

void clear_cin();
void fnTest_terminate();

// typedef void (__cdecl *terminate_function)()
void my_terminate_function();
void test_try_catch();

/// 声明接口异常
/// 在函数后面修饰 throw(x, y, z)
/// 说明该函数要抛出哪种异常, 给调用者看的

/// 函数后面的throw修改, 说明本函数要抛出什么类型的异常
/// 但是M$并没有在函数中校验throw的类型是否和函数说明相同
/// throw可以修饰一个函数中抛出的多个异常
void fnOnTryCatch(char* pIn) throw(CMyException*, int);

/// throw() 表明, 该函数保证不抛出任何异常
void fnOnTryCatch1(char* pIn) throw();

int main(int argc, char** argv, char** envp)
{
    test_try_catch();

    // fnTest_terminate();
    cout << "END, press any key to quit" << endl;
    clear_cin();
    getchar();

    return 0;
}

void test_try_catch()
{
    char* p = NULL;

    /// 如果没有catch能接住异常, 被OS接住后, 直接弹abort框
    /// CTestThrow Test1; ///< 模拟没有catch能接住异常的情况

    try
    {
        // 如果Test2的构造中抛出异常, CTestThrow中缺没能catch住异常, Test2的析构不会被调用
        CTestThrow Test2;

        fnOnTryCatch1(p); ///< 前面抛出了异常, 这句也就不会被执行.
        // fnOnTryCatch(p);
    }
    
    /// 用基类指针去捕获异常
    /// throw的是具体异常子类的指针
    catch (IMyExceptionBase* pe)
    {
        if (NULL != pe)
        {
            cout << pe->GetErrMsg() << endl;
            delete pe;
            pe = NULL;
        }
    }

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

void fnOnTryCatch1(char* pIn)
{
    if (NULL != pIn)
    {
        /// 但是M$并没有在函数中校验throw的类型是否和函数说明相同
        // throw((int)2); ///< M$
        *pIn = 'e';
    }
}

void fnOnTryCatch(char* pIn)
{
    if (NULL == pIn)
    {
        // throw((int)2);

        /// 但是M$并没有在函数中校验throw的类型是否和函数说明相同
        // throw((double)3);
        throw(new CMyException("fnOnTryCatch (NULL == pIn)"));
    }

    *pIn = 't';
}


void fnTest_terminate()
{
    // terminate(); ///< 调用了 abort
    set_terminate(my_terminate_function);
    terminate();
}

void my_terminate_function()
{
    /// 可以做些收尾的事情
    cout << "my_terminate_function()" << endl;

    /// 如果不调用 exit, OS会调用abort, 很不体面的弹abort框
    exit(0); ///< 这样就不会弹框了
}

void clear_cin()
{
    cin.clear();
    cin.sync();
}

// MyException.cpp: implementation of the CMyException class.
//
//

#include "MyException.h"

//
// Construction/Destruction
//

CMyException::CMyException(const char* pcErrMsg)
:m_pcErrMsg(pcErrMsg)
{

}

CMyException::~CMyException()
{

}

const char* CMyException::GetErrMsg()
{
    return m_pcErrMsg;
}

// MyException.h: interface for the CMyException class.
//
//

#if !defined(AFX_MYEXCEPTION_H__96603384_DB81_48CE_8173_29BC2A82F26A__INCLUDED_)
#define AFX_MYEXCEPTION_H__96603384_DB81_48CE_8173_29BC2A82F26A__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

#include "MyExceptionBase.h"

class CMyException : public IMyExceptionBase  
{
public:
	CMyException(const char* pcErrMsg);
	virtual ~CMyException();

    virtual const char* GetErrMsg(); ///< 接口, 取错误消息

private:
    const char* m_pcErrMsg;
};

#endif // !defined(AFX_MYEXCEPTION_H__96603384_DB81_48CE_8173_29BC2A82F26A__INCLUDED_)

// MyExceptionBase.cpp: implementation of the CMyExceptionBase class.
//
//

#include "MyExceptionBase.h"

//
// Construction/Destruction
//

IMyExceptionBase::IMyExceptionBase()
{

}

IMyExceptionBase::~IMyExceptionBase()
{

}

// MyExceptionBase.h: interface for the CMyExceptionBase class.
//
//

#if !defined(AFX_MYEXCEPTIONBASE_H__90DA9DC6_7686_417F_801B_2DC4F1E7A3C5__INCLUDED_)
#define AFX_MYEXCEPTIONBASE_H__90DA9DC6_7686_417F_801B_2DC4F1E7A3C5__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class IMyExceptionBase  
{
public:
	IMyExceptionBase();
	virtual ~IMyExceptionBase() = 0;

    virtual const char* GetErrMsg() = 0; ///< 接口, 取错误消息
};

#endif // !defined(AFX_MYEXCEPTIONBASE_H__90DA9DC6_7686_417F_801B_2DC4F1E7A3C5__INCLUDED_)

// TestThrow.cpp: implementation of the CTestThrow class.
//
//

#include <stddef.h>
#include <iostream>
using namespace std;

#include "TestThrow.h"
#include "MyException.h"

//
// Construction/Destruction
//

CTestThrow::CTestThrow()
{
    /// 构造函数失败时, 可以抛出异常
    /// 假设资源分配失败, 要抛出异常

    /// 如果抛出的异常, 没有被我们的catch接住, 被OS接住后, 直接弹abort框
    /// 在类中抛出异常后, 如果没有在类中catch住, 就不会自动调用析构.

    /// 如果在类中需要抛出异常, 而且本类没有catch能接住该异常, 
    /// 要先释放能释放的资源, 才能throw异常 
    
    /// 必须在构造函数中的try中抛出异常的类
    /// 才会在本类生命期结束的时候, 自动析构
    /// 如果被其他作用域的catch捕获, 本类的析构不会被调用

    throw(new CMyException("failed CTestThrow::CTestThrow()"));
}

CTestThrow::~CTestThrow()
{
    /// 析构函数中, 从语法上讲, 是不应该抛出异常的 
    /// 如果一个类已经在销毁了, 可是有问题, 我们也做不了什么
    /// 所以 : 析构函数不应该抛出异常
    // throw(new CMyException("failed CTestThrow::~CTestThrow()"));
    cout << "CTestThrow::~CTestThrow()" << endl;
}

// TestThrow.h: interface for the CTestThrow class.
//
//

#if !defined(AFX_TESTTHROW_H__573ED8BA_B817_440C_9D67_14CBCA9EA6FC__INCLUDED_)
#define AFX_TESTTHROW_H__573ED8BA_B817_440C_9D67_14CBCA9EA6FC__INCLUDED_

#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000

class CTestThrow  
{
public:
	CTestThrow();
	virtual ~CTestThrow();

};

#endif // !defined(AFX_TESTTHROW_H__573ED8BA_B817_440C_9D67_14CBCA9EA6FC__INCLUDED_)