构造函数中抛出异常造成静态成员重新初始化的问题

zyobi · 发表于 2006-10-1 20:09:29

写了一个支持对象计数的类，代码如下：

/**
* @file Counted.h
* This is the header of class Counted.
*/
#ifndef COUNTED_H_
#define COUNTED_H_
#include <iostream>
namespace myclass
{
/**
* @class Counted
* @brief The base class used to count objects.
*
* This class is used to confine the number of objects.
* If the number exceeds the max number, then a exception
* called TooManyObjects will be throwed out.
*/
template <class BeingCounted>
class Counted
{
public:
/**
* @class TooManyObjects
* @brief The class of exception which will be throwed
* while there are too many objects.
*
* This class is a member class of Counted, and will be
* throwed only by the class Counted. In the derived class
* of Counted, the class should be declared as public, so
* that the exception can be captured.
*/
class TooManyObjects
{
public:
TooManyObjects(){};
virtual ~TooManyObjects(){};
};
/**
* @fun objectCount
* @brief Provider the number of objects of the object.
* @return The number of objects.
*
* Get the number of objects for the derived class.
*/
static int objectCount();
public:
Counted();
Counted(const Counted& rhs);
virtual ~Counted();
private:
static size_t numObjects; ///< The number of objects.
static const size_t maxObjects; ///< The max number of objects.
/**
* @fun init
* @brief Intialize the object.
*
* Because the constructor and the copy constructor have
* the operations, so a function is needed here to avoid
* the repeat code.
*/
void init();
};
template<class BeingCounted>
size_t Counted<BeingCounted>::numObjects = 0; // Note here the value of numObjects is 0.
// template<class BeingCounted>
// const size_t Counted<BeingCounted>::maxObjects = 1;
template<class BeingCounted>
int Counted<BeingCounted>::objectCount()
{
return numObjects;
}
template<class BeingCounted>
Counted<BeingCounted>::Counted()
{
init();
}
template<class BeingCounted>
Counted<BeingCounted>::Counted(const Counted <BeingCounted>&)
{
init();
}
template<class BeingCounted>
Counted<BeingCounted>::~Counted()
{
-- numObjects;
}
template<class BeingCounted>
void Counted<BeingCounted>::init()
{
if(numObjects >= maxObjects)
{
throw TooManyObjects();
}
++ numObjects;
}
}
#endif /*COUNTED_H_*/

复制代码

// file TestCounted.h
#ifndef TESTCOUNTED_H_
#define TESTCOUNTED_H_
#include "Counted.h"
namespace myclass
{
class TestCounted: Counted<TestCounted>
{
public:
TestCounted();
virtual ~TestCounted();
using Counted<TestCounted>::objectCount;
using Counted<TestCounted>::TooManyObjects;
};
}
#endif /*TESTCOUNTED_H_*/

复制代码

// file TestCounted.cpp
#include "TestCounted.h"
namespace myclass
{
template<typename TestCounted> const size_t Counted<TestCounted>::maxObjects = 2;
TestCounted::TestCounted()
{
}
TestCounted::~TestCounted()
{
}
}

复制代码

// file main.cpp
#include <iostream>
#include "TestCounted.h"
#include "Counted.h"
using namespace std;
using namespace myclass;
int main()
{
try
{
TestCounted t1;
TestCounted t2;
TestCounted t3;
}
catch(TestCounted::TooManyObjects& e)
{
cout << "The number of objects is " << TestCounted::objectCount() << "!\n";
//throw;
}
return (0);
}

复制代码

其中Counted是支持对象计数的基类，当对象个数超出设定的最大数值时，有一个异常将被抛出。设定的对象最大个数是2.TestCounted私有继承了Counted，因此具有了对象计数能力。

在main函数中，创建3个TestCounted对象，这将导致异常被抛出，通过try-catch块捕捉，然后输出此时的对象个数，却惊奇地发现输出的对象个数为0！也就是说，类的静态成员numObjects又被重新初始化了。编译环境是Gcc4.0.3。

请问这是什么原因造成的？是否属于C++的异常机制？谢谢！

svenwang · 发表于 2006-10-2 02:11:23

类的构造函数不应该设计为有可能抛异常，构造函数应该设计为异常安全的

zyobi · 发表于 2006-10-2 09:37:38

Post by svenwang
类的构造函数不应该设计为有可能抛异常，构造函数应该设计为异常安全的

嗯，受教了。可是如果需要检测对象构造失败的情况，就必须在构造函数中使用异常。异常抛出时，C++标准规定对象里已经构造好的字对象将被逆序地析构。怪就怪在还会将静态成员重新初始化。

zyobi · 发表于 2006-10-2 10:53:05

解决了，设计上的问题。t1和t2在catch块中时已经被析构了，因此计数为0.

		自动登录	找回密码
密码			注册

构造函数中抛出异常造成静态成员重新初始化的问题

浏览过的版块