C++中通过异常让构造函数不创建类的对象

在实际使用过程中，有时候会遇到想让构造函数不返回类的对象的情形，例如，对于有参数的构造函数，可能需要进行合法性检查，如果不通过检查则不创建对象，如果通过则创建。对于当前的C++编程而言，只要通过A *a = new A()或者A a，进行类对象的声明或者指针对象的构建，都会得到一个A的对象或者对象指针。既然不是NULL（空指针）则用户就可以使用该指针进行后续的非法操作。因为构造函数没有返回值，所以我们没有办法确认到底是否需要创建对象，而实际上不管是否需要创建，构造函数都创建了。我们也无法再使用if(a==NULL)来判断是否为空（肯定不为空）。鉴于此，我们需要增加一种手段来确保不该创建对象的时候不创建对象。

手段1：类中增加一个标志位flag，如果参数检查通过flag置为true，表示创建的类的对象A a合法，可以后续使用；否则不合法，应当执行析构函数a.~A();

手段2：只保留一个无参的构造函数，具体的操作（参数检查等）通过init()来实现，而init是有返回值的，通过返回值来确认前面创建的对象是否合法。

上述两种方法都避免不了创建对象，都是事后判断是否合法，合法则用，不合法则弃。

手段3：通过throw excpetion的方式来打断创建对象的过程。这要求在构造函数的适当位置增加throw(new xxxException());语句，表示构造函数出现了异常；然后在类对象的构造时使用try{ A a;或者A *a = new A()} catch(xxxException e){}的方式来捕获异常，这样就可以打断构造函数，不返回类的对象或者对象指针为NULL。

文件清单如下：

1. 主函数main.cpp如下：

//main.cpp

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

#include <iostream>
#include <limits>

#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;
    CTestThrow *Test2 = NULL;
    CTestThrow *Test = NULL;
    /// 如果没有catch能接住异常, 被OS接住后, 直接弹abort框
    /// CTestThrow Test1; ///< 模拟没有catch能接住异常的情况

    try
    {
        Test = new CTestThrow(5);
        Test->print();
        cout<<"------------------"<< '\n';
        // 如果Test2的构造中抛出异常, CTestThrow中缺没能catch住异常, Test2的析构不会被调用
        
        Test2 = new CTestThrow();
        
        Test2->print();
        fnOnTryCatch1(p); ///< 前面抛出了异常, 这句也就不会被执行.
        // fnOnTryCatch(p);
    }

    /// 用基类指针去捕获异常
    /// throw的是具体异常子类的指针
    catch (IMyExceptionBase *pe)
    {
        if (NULL != pe)
        {
            cout << pe->GetErrMsg() << endl;
            delete pe;
            pe = NULL;
        }
    }

    catch (...)
    {
        cout << "catch(...)" << endl;
    }
    if (Test2 == NULL)
    {
        cout << "Test2 constructor throws exception, the object is NULL." << '\n';
    }
    else
    {
        cout << "Test2 constructor throws exception, but the object is not NULL." << '\n';
    }

    if(Test == NULL)
    {
        cout << "Test is NULL." << '\n';
    }
    else
    {
        cout << "Test is not NULL. " << '\n';
        Test->print();
    }
}
void fnOnTryCatch1(char *pIn)
{
    if (NULL != pIn)
    {
        /// 但是M$并没有在函数中校验throw的类型是否和函数说明相同
        // throw((int)2); ///< M$
        *pIn = 'e';
    }
}

void fnOnTryCatch(char *pIn) throw(CMyException *, int)
{
    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();
}

2. 定义的异常基类头文件myExceptionBase.h如下：

//myExceptionBase.h
class IMyExceptionBase  
{
public:
	IMyExceptionBase();
	virtual ~IMyExceptionBase() = 0;
 
    virtual const char* GetErrMsg() = 0; ///< 接口, 取错误消息
};

 3. 定义的异常基类的实现myExceptionBase.cpp（可以合并到.h文件中）如下：

#include "myExceptionBase.h"
 
//
// Construction/Destruction
//
 
IMyExceptionBase::IMyExceptionBase()
{
 
}
 
IMyExceptionBase::~IMyExceptionBase()
{
 
}

4. 基于异常基类实现的一个具体异常类cMyException.h文件如下：

    #include "myExceptionBase.h"
     
    class CMyException : public IMyExceptionBase  
    {
    public:
    	CMyException(const char* pcErrMsg);
    	virtual ~CMyException();
     
        virtual const char* GetErrMsg(); ///< 接口, 取错误消息
     
    private:
        const char* m_pcErrMsg;
    };
     

5. 基于异常基类实现的一个具体异常类的实现cMyException.cpp文件如下：

#include "cMyException.h"
//
// Construction/Destruction
//
 
CMyException::CMyException(const char* pcErrMsg)
:m_pcErrMsg(pcErrMsg)
{
 
}
 
CMyException::~CMyException()
{
 
}
 
const char* CMyException::GetErrMsg()
{
    return m_pcErrMsg;
}

 6. 准备使用异常的类的头文件testThrow.h如下：

#include <iostream>
#include "cMyException.h"
class CTestThrow  
{
public:
	CTestThrow();
	CTestThrow(int b);
	virtual ~CTestThrow();
	void print();
private:
	int a;
 
};

7. 准备使用异常的类的具体实现testThrow.cpp如下：

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

 
CTestThrow::CTestThrow()
{
    /// 构造函数失败时, 可以抛出异常
    /// 假设资源分配失败, 要抛出异常
 
    /// 如果抛出的异常, 没有被我们的catch接住, 被OS接住后, 直接弹abort框
    /// 在类中抛出异常后, 如果没有在类中catch住, 就不会自动调用析构.
 
    /// 如果在类中需要抛出异常, 而且本类没有catch能接住该异常, 
    /// 要先释放能释放的资源, 才能throw异常 
    
    /// 必须在构造函数中的try中抛出异常的类
    /// 才会在本类生命期结束的时候, 自动析构
    /// 如果被其他作用域的catch捕获, 本类的析构不会被调用
 
    throw(new CMyException("failed CTestThrow::CTestThrow()"));
}
CTestThrow::CTestThrow(int b)//没有使用异常
{
    a  = b;
}
	
void CTestThrow::print()
{
    printf("a = %d\n", a);
}
 
CTestThrow::~CTestThrow()
{
    /// 析构函数中, 从语法上讲, 是不应该抛出异常的 
    /// 如果一个类已经在销毁了, 可是有问题, 我们也做不了什么
    /// 所以 : 析构函数不应该抛出异常
    // throw(new CMyException("failed CTestThrow::~CTestThrow()"));
    cout << "CTestThrow::~CTestThrow()" << endl;
}

编译以及测试结果：（Test2对应的构造函数里面抛出了异常，所以返回后指针为空，后续无法使用，而Test对应的构造函数没有抛出异常，后续可以正常使用该指针）