limit the number of instance of a class - c++

Question

I want to put a limit on the number of instances you can make of a class.
I have the following code:
class A {
static int cnt;
int x;
public:
A() {
cout<<"ctor called\n";
}
void* operator new(size_t size_in) {
if(cnt<=10) {
void *p=malloc(size_in);
if(p==NULL) {
throw bad_alloc();
} else {
cout<<"Memory allocation successful\n";
++cnt;
return p;
}
} else {
throw bad_alloc();
}
}
~A() {
cout<<"Cleaning up the mess\n";
}
};
int A::cnt=0;
int main() {
A *a[20];
for(int i=0;i<20;++i) {
try {
a[i]=new A();
} catch (bad_alloc &e) {
cout<<"Error in allocating memory\n";
}
}
try {
A b;
} catch (bad_alloc &e) {
cout<<"Error in allocating memory on stack\n";
}
return 0;
}
Using a static counter and overloading the new operator I am able to put a limit on the number of objects that can be created on Heap. I want to limit the number of instances created on Stack also. One way is to make constructor private and provide a public API which first checks the counter and then returns accordingly.
Is there any other way of doing this?

Answer 1

Is there any other way of doing this??
You may just increase and check the counter in the constructor, the object will be destroyed if you throw an exception out of it. Furthermore, you won't have to distinguish between stack and heap.

Answer 2

The best way to do it is to create helper template class and count objects using constructor and destructor:
class instance_limit_reached : public std::logic_error
{
public:
using logic_error::logic_error;
};
template<typename T, int MaxInst>
class LimitInstances
{
static std::atomic<int> instanceCount;
void onNewInstance() {
chekcTheLimit();
++instanceCount;
}
void chekcTheLimit() {
if (instanceCount >= MaxInst)
throw instance_limit_reached(std::string("Limit reached for ") + typeid(T).name());
}
public:
~LimitInstances() {
--instanceCount;
}
LimitInstances() {
onNewInstance();
}
LimitInstances(const LimitInstances<T, MaxInst> &) {
onNewInstance();
}
LimitInstances(LimitInstances<T, MaxInst> &&) {
onNewInstance();
}
};
Live example with field use or example with CRTP
Now there is one important question, when object is moved do you consider this as a new instance (my example) or old instance (my code needs tweaking)?

Answer 3

For fun, this is how I would do it: a CRTP design to be reusable with thread safe code:
template<class ToLimit,size_t MaxInstances>
class InstanceLimiter{
static inline std::atomic<int> instances=0;
private:
static increase_count(){
//memory order relaxed is sufficient because there is
//only one modification order for each atomic objects.
int actual=instances.load(std::memory_order_relaxed);
do{
if (actual>=MaxInstances) throw some_error{};
} while (instances.compare_exchange_weak(actual,actual+1,
std::memory_order_relaxed,std::memory_order_relaxed));
}
protected:
//Provide definition for default constructor, copy constructor
// and copy assignment operator so that defaulted derived special
// member function behave as expected.
InstanceLimiter(){increase_count();}
InstanceLimiter(const InstanceLimiter&){increase_count();}
InstanceLimiter& operator=(const InstanceLimiter&){
increase_count();
return *this;
}
~InstanceLimiter(){
instances.fetch_add(-1,std::memory_order_relaxed);
}
};
class A: InstanceLimiter<A,10> {
int x;
public:
A() {
//InstanceLimiter default constructor implicitly called
cout<<"ctor called\n";
}
A(int x)
//InstanceLimiter default constructor implicitly called here
:x{x}{}
//Implicitly declarer move/copy constructor/assignement implicitly calls
// the copy constructor/assignment of InstanceLimiter
~A() {
cout<<"Cleaning up the mess\n";
//Default destructor of InstanceLimiter implicitly called here.
}
};
Last but not least: if you plan to use it in real code, consider to make your class A noexcept default and move constructible by providing it a default state that does not count as an instance.

Answer 4

I want to limit the number of instances created on Stack also
If you want different limits for Heap and Stack object, it seem to me that the cleaner way is the one of the private constructor with friend make functions (one for heap objects and one for stack object) with counters inside the make functions.
I mean... you can write A as follows
class A
{
private:
int x;
A (int x0 = 0)
{ std::cout << "ctor called" << std::endl; }
public:
~A()
{ std::cout << "cleaning up the mess" << std::endl; }
friend A * makeAinHeap (int);
friend A makeAinStack (int);
};
and the make-in-heap function is simply
A * makeAinHeap (int x)
{
constexpr auto maxAH { 3u };
static auto ah { 0u };
if ( ++ah > maxAH )
throw std::runtime_error("no more A in Heap");
return new A{x};
}
and the analogous make-in-stack function is
A makeAinStack (int x)
{
constexpr auto maxAS { 2u };
static auto as { 0u };
if ( ++as > maxAS )
throw std::runtime_error("no more A in Stack");
return A{x};
}
You can check all with the following main()
int main ()
{
auto p1 { makeAinHeap(0) }; // OK
auto p2 { makeAinHeap(0) }; // OK
auto p3 { makeAinHeap(0) }; // OK
//auto p4 { makeAinHeap(0) }; // throw an exception
auto s1 { makeAinStack(0) }; // OK
auto s2 { makeAinStack(0) }; // OK
//auto s3 { makeAinStack(0) }; // throw an exception
delete p1;
delete p2;
delete p3;
}