异常处理

异常处理

简历稳定的系统

为了防止资源泄露， 用以下两种方式来防止 “不成熟的” 的资源分配

1.  在构造函数中捕获异常，用于释放资源。

2. 在对象的构造函数中分配资源， 并且在析构函数中释放资源

以下代码是不成熟的分配方式，  极易造成问题：

#include "stdafx.h"

#include <iostream>

#include <cstddef>

using namespace std;

class Cat

{

public:

Cat()

{

cout<<"Cat()"<<endl;

}

~Cat()

{

cout<<"~Cat()"<<endl;

}

void g() {}

};

class Dog

{

public:
// 重载new 运算符

void* operator new[] (size_t)

{

cout<<"Allocating a Dog"<<endl;

throw 47;

}

// 重载delete运算符

void operator delete[] (void* p)

{

cout<<"Deallocating a Dog"<<endl;

::operator delete[] (p);

}

};

class UseResources

{

Cat*  cats;

Dog*　dog;

public:

UseResources(int count = 1)

{

cout<<"UseResources()"<<endl;

cats = new Cat[count];

dog  = new Dog;

}

~UseResources()

{

cout<<"~UseResource()"<<endl;

delete [] cats;

delete Dog;

}

};

int _tmain(int argc, _TCHAR* argv[])

{

try

{

UseResources ur(3);

}

catch(int)

{

cout<<"inside handler"<<endl;

}

catch(...)

{

cout<<"inside catch(....)"<<endl;

}

system("pause");

return 0;

}

程序的输出结果是：

UseResources()
Cat()
Cat()
Cat()
allocating a Dog
inside handler

程序执行到UserResources构造函数中， Cat的构造函数成功的完成数组对象中的三个对象，然而在  Dog::operator new()
函数中抛出一个异常。   程序执行异常处理器之时突然中止，UseResources的析构函数没有被调用。这是正确的，
但是 UseResources 的构造函数没有完成， 这说明在堆上的Cat对象是不会被销毁的。

为了防止资源泄露， 用以下两种方式来防止 “不成熟的” 的资源分配

1.  在构造函数中捕获异常，用于释放资源。

2. 在对象的构造函数中分配资源， 并且在析构函数中释放资源

#include  "stdafx.h"

#include  <iostream>

#include  <cstddef>

//  在构造中分配资源

template < class  T, int sz = 1>

class   PWrap

{

        T *   ptr   ;

public :

        class   RangeError   {};

        PWrap ()

     {

             //   在构造中分配资源

             ptr   =   new   T [   sz ];

             cout << "PWrap constructor"   << endl ;

     }

     ~   PWrap ()

     {

             //   在析构中释放资源

             delete   []   ptr   ;

             cout << "PWrap destructor"   << endl ;

     }

        T &   operator   []( int   i )   throw   ( RangeError )

     {

             //   返回下标的引用值

             if ( i   >= 0 &&   i   <   sz )

                 return   ptr   [ i ];

             throw   RangeError   ();

     }

};

class   Cat

{

public :

        Cat ()

     {

             cout << "Cat()"   << endl ;

     }

     ~   Cat ()

     {

             cout << "~Cat()"   << endl ;

     }

        void   g   () {}

};

class   Dog

{

public :

        void *   operator   new [] (   size_t )

     {

             cout << "Allocating a Dog"   << endl ;

             throw   47;

     }

        void   operator   delete [] (   void *   p   )

     {

             cout << "Deallocating a Dog"   << endl ;

          ::   operator   delete   [] ( p );

     }

};

class   UseResources

{

        PWrap < Cat   , 3>   cats ;

        PWrap < Dog   >      dog ;

public :

        UseResources ()

     {

             cout << "UseResources()"   << endl ;

     }

     ~   UseResources ()

     {

             cout << "~UseResource()"   << endl ;

     }

        void   f   ()

     {

             cats [1]. g   ();

     }

};

int   _tmain   ( int   argc ,   _TCHAR   *   argv [])

{

        try

     {

             UseResources   ur   ;

     }

        catch ( int   )

     {

             cout << "inside handler"   << endl ;

     }

        catch (...)

     {

             cout << "inside catch(....)"   << endl ;

     }

     

        system ( "pause"   );

        return   0;

}