Ограничение количества объектов класса

#include <iostream>
#include <vector>
 
class Foo
{
public:
    ~Foo()
    {
        --current_count;
    }
    
    static Foo *instance(int foo = 0)
    {
        if (current_count >= max_count)
            return 0;
        
        ++current_count;
        
        return new Foo(foo);
    }
    
    static Foo *instance(const Foo& source)
    {
        return instance(source.get_foo());
    }
    
    int get_foo() const
    {
        return m_foo;
    }
    
    void set_foo(int foo)
    {
        m_foo = foo;
    }
    
private:
    static const size_t max_count = 10;
    static size_t current_count;
    
private:
    Foo(int foo = 0)
    {
        set_foo(foo);
    }
    
    Foo(const Foo& source)
    {
        set_foo(source.get_foo());
    }
    
    Foo& operator=(const Foo& source)
    {
        set_foo(source.get_foo());
        
        return *this;
    }
    
private:
    int m_foo;
};
 
size_t Foo::current_count = 0;
 
int main()
{
    std::vector<Foo *> vec;
    int x = 0;
    
    for (Foo *inst = Foo::instance(x++); inst != 0; inst = Foo::instance(x++))
        vec.push_back(inst);
    
    for (size_t i = 0; i < vec.size(); ++i)
        std::cout << vec[i]->get_foo() << "  ";
    
    std::cout << std::endl;
    
    for (size_t i = 0; i < vec.size(); ++i)
        delete vec[i];
    
    return 0;
}

#include <cstdlib>
#include <iostream>
 
template <class T>
class Calculated
{
public:
        Calculated() { ++m_count; }
        Calculated(const Calculated&) { ++m_count; }
        ~Calculated(){ --m_count; }
        static unsigned getCount() { return m_count; }
private:
        static unsigned m_count;
};
 
class Restricted1
{
public:
        Restricted1()  { std::cout << "+"; }
        ~Restricted1() { std::cout << "-"; }
};
 
class Restricted2
{
public:
        Restricted2()  { std::cout << "(+)"; }
        ~Restricted2() { std::cout << "(-)"; }
};
 
template<class T> unsigned Calculated<T>::m_count = 0;
 
template <class T, const unsigned max>
class RestrictFactory
{
public:
        class CRestricted : public T, Calculated<T> {};
        static T* instance()
        {
                if (Calculated<T>::getCount() == max) return NULL;
                return new CRestricted;
        }
};
 
typedef RestrictFactory<Restricted1, 5> Factory1;
typedef RestrictFactory<Restricted2, 3> Factory2;
 
int main()
{
        Restricted1* r1[10];
        for (unsigned i=0 ; i<10 ; ++i) r1[i] = Factory1::instance();
        for (unsigned i=0 ; i<10 ; ++i) delete r1[i];   
        
        Restricted2* r2[10];
        for (unsigned i=0 ; i<10 ; ++i) r2[i] = Factory2::instance();
        for (unsigned i=0 ; i<10 ; ++i) delete r2[i];
}

class Foo {
public:
    Foo() { }
    ~Foo() { }
};
 
class FooManager {
 
private:
    int count = 0;
 
public:
    FooManager(int max_count = 10) {
        this->max_count = max_count;
    }
 
    Foo* createFoo() {
        if (count == max_count) return 0;
 
        ++count;
        return new Foo();
    }
};
 
static FooManager manage();
 
void main() {
    
    Foo* f = manager.createFoo();
    f->~Foo();
}