[总结]C++实现一个限制对象实例个数的类
2009-03-02 19:55
513 查看
C++实现一个限制对象实例个数的类
absolute8511 总结于 09-3-2
这个问题有两方面的需求,一个是单例模式,只能创建一个对象,另一种是限制创建的对象个数。这两种情况类似,实现原理也是类似的。
它们的基本原理:1.构造函数私有化;2. 提供自己的静态构造函数
对于单例模式,构造一个static对象,以后返回该对象即可。对于限制对象个数的多例模式,需添加一个静态字段记录创建的对象个数,在私有构造函数中对该字段进行检查,在析构函数递减该字段即可。
实现如下:
1. Counted类是所有需要应用该模式的基类。
template<class BeingCounted> class Counted
{
public:
class TooMany{}; //用于抛出异常的类,也可以在对象过多时返回NULL
//用于客户端获取目前已有的对象个数
static size_t objectCount()
{
return numObjects;
}
protected:
Counted();
Counted(const Counted& rhs);
//析构函数使对象计数减1
~Counted()
{
--numObjects;
}
private:
//记录对象个数
static size_t numObjects;
//允许的最多的对象个数,由派生类自己设定限制个数
static const size_t maxObjects;
void init();
};
template<class BeingCounted> size_t Counted<BeingCounted>::numObjects = 0;
template<class BeingCounted> Counted<BeingCounted>::Counted()
{
init();
}
template<class BeingCounted> Counted<BeingCounted>::Counted(const Counted<BeingCounted>& rhs)
{
init();
}
template<class BeingCounted> void Counted<BeingCounted>::init()
{
if(numObjects>=maxObjects)
throw TooMany();
++numObjects;
}
2. 对于需要单例模式的类可以实现如下,从Counted私有派生:
class Limiter1:private Counted<Limiter1>
{
public:
~Limiter1();
//由于私有继承,隐藏了以下两个东西,为了使客户端可见,使用using将它们加入到公有接口中
using Counted<Limiter1>::objectCount;
using Counted<Limiter1>::TooMany;
static Limiter1& GetLimiter1Inst();
private:
Limiter1();
Limiter1(const Limiter1& rhs);
};
//设定限制个数为1,即单例模式
const size_t Counted<Limiter1>::maxObjects = 1;
//客户端将调用该函数获取对象实例
Limiter1& Limiter1::GetLimiter1Inst()
{
static Limiter1 Inst;
return Inst;
}
Limiter1::Limiter1()
{
printf("Limiter1 created!\n");
}
Limiter1::~Limiter1()
{
printf("Limiter1 destroy!\n");
}
3. 限制一定个数的对象的实现方法:
class Limiter2:private Counted<Limiter2>
{
public:
static Limiter2* makeLimiter2();
~Limiter2();
using Counted<Limiter2>::objectCount;
using Counted<Limiter2>::TooMany;
private:
Limiter2();
Limiter2(const Limiter2& rhs);
};
//限制对象个数为4
const size_t Counted<Limiter2>::maxObjects = 4;
//客户端调用该函数获取对象,由于new会调用基类的构造函数,而基类的构造函数会判断实例个数,因此实现了限制个数的目的
Limiter2* Limiter2::makeLimiter2()
{
return new Limiter2();
}
Limiter2::Limiter2()
{
printf("Limiter2 created!");
}
Limiter2::~Limiter2()
{
printf("Limiter2 destroy!");
}
absolute8511 总结于 09-3-2
这个问题有两方面的需求,一个是单例模式,只能创建一个对象,另一种是限制创建的对象个数。这两种情况类似,实现原理也是类似的。
它们的基本原理:1.构造函数私有化;2. 提供自己的静态构造函数
对于单例模式,构造一个static对象,以后返回该对象即可。对于限制对象个数的多例模式,需添加一个静态字段记录创建的对象个数,在私有构造函数中对该字段进行检查,在析构函数递减该字段即可。
实现如下:
1. Counted类是所有需要应用该模式的基类。
template<class BeingCounted> class Counted
{
public:
class TooMany{}; //用于抛出异常的类,也可以在对象过多时返回NULL
//用于客户端获取目前已有的对象个数
static size_t objectCount()
{
return numObjects;
}
protected:
Counted();
Counted(const Counted& rhs);
//析构函数使对象计数减1
~Counted()
{
--numObjects;
}
private:
//记录对象个数
static size_t numObjects;
//允许的最多的对象个数,由派生类自己设定限制个数
static const size_t maxObjects;
void init();
};
template<class BeingCounted> size_t Counted<BeingCounted>::numObjects = 0;
template<class BeingCounted> Counted<BeingCounted>::Counted()
{
init();
}
template<class BeingCounted> Counted<BeingCounted>::Counted(const Counted<BeingCounted>& rhs)
{
init();
}
template<class BeingCounted> void Counted<BeingCounted>::init()
{
if(numObjects>=maxObjects)
throw TooMany();
++numObjects;
}
2. 对于需要单例模式的类可以实现如下,从Counted私有派生:
class Limiter1:private Counted<Limiter1>
{
public:
~Limiter1();
//由于私有继承,隐藏了以下两个东西,为了使客户端可见,使用using将它们加入到公有接口中
using Counted<Limiter1>::objectCount;
using Counted<Limiter1>::TooMany;
static Limiter1& GetLimiter1Inst();
private:
Limiter1();
Limiter1(const Limiter1& rhs);
};
//设定限制个数为1,即单例模式
const size_t Counted<Limiter1>::maxObjects = 1;
//客户端将调用该函数获取对象实例
Limiter1& Limiter1::GetLimiter1Inst()
{
static Limiter1 Inst;
return Inst;
}
Limiter1::Limiter1()
{
printf("Limiter1 created!\n");
}
Limiter1::~Limiter1()
{
printf("Limiter1 destroy!\n");
}
3. 限制一定个数的对象的实现方法:
class Limiter2:private Counted<Limiter2>
{
public:
static Limiter2* makeLimiter2();
~Limiter2();
using Counted<Limiter2>::objectCount;
using Counted<Limiter2>::TooMany;
private:
Limiter2();
Limiter2(const Limiter2& rhs);
};
//限制对象个数为4
const size_t Counted<Limiter2>::maxObjects = 4;
//客户端调用该函数获取对象,由于new会调用基类的构造函数,而基类的构造函数会判断实例个数,因此实现了限制个数的目的
Limiter2* Limiter2::makeLimiter2()
{
return new Limiter2();
}
Limiter2::Limiter2()
{
printf("Limiter2 created!");
}
Limiter2::~Limiter2()
{
printf("Limiter2 destroy!");
}
相关文章推荐
- C++实现一个限制对象实例个数的类
- C++实现一个类只有一个实例对象
- C++学习总结_声明一个对象并实现声明类的方法
- 【c++总结-类】一个例子知道类的创建,对象,函数实现,构造函数,析构函数
- 简单工厂(Factory)-提供一个创建对象实例的功能,而无须关心其具体实现。被创建实例的类型可以是接口、抽象类,也可以是具体的类。
- Map接口及其重要实现类的方法总结:从HashMap中放入,查找,删除一个对象,并将全部value放入到一个数组中;获得HashMap的全部数据
- c++在调用类的时候不一定非得实例化对象哦,有时候你不写系统会为你默认生成一个临时实例对象哦~
- C#实现让程序只能打开一个实例(总结3方法)(转)
- [技巧] C#实现让程序只能打开一个实例(总结3方法)
- 怎么限制一个类的对象实例,只能在"堆"上分配,或者只能在"栈"上分配
- 利用内核对象----互斥量实现应用程序只运行一个实例
- More Effective C++ Item 附2:一个auto_ptr的实现实例
- Java中如何实现一个类在内存里只能创建一个实例对象
- C#实现让程序只能打开一个实例(总结3方法)
- 实例化一个子类对象赋给父类对象引用或一个实现了接口的类的对象赋给接口的引用的好处
- (大卫的阅读笔记)More Effective C++ Item 附2:一个auto_ptr的实现实例
- winform实现让程序只能打开一个实例(总结3方法)
- 定义一个List集合并实例化对应的实现类对象。循环输入任意个整数,输入0结束输入循环,对集合中的数据进行从大到小的排序后输出
- 实现 一个类,使得该类任何形式的 派生类 无论怎么定义和实现,都无法产生任何对象 实例 (原创)
- C++实现线程同步的几种方式 线程同步是指同一进程中的多个线程互相协调工作从而达到一致性。之所以需要线程同步,是因为多个线程同时对一个数据对象进行修改操作时,可能会对数据造成破坏,下面是多