Реализации на С++

Object pool

Общая реализация на языке С++

EmployeePoolObject

template <typename T>
concept EmployeePoolObject = requires(T t)
{
	t.clockIn();
};

Employee

class Employee
{
private:
	static size_t count;

public:
	Employee() 
	{ 
		cout << "Constructor(" << ++count << ");" << endl; 
	}
	
	~Employee() 
	{ 
		cout << "Destructor(" << count-- << ");" << endl; 
	}

	void clockIn() 
	{ 
		cout << "Employee clocked in: 0x" << this << endl; 
	}
};

size_t Employee::count = 0;

EmployeePool

template <EmployeePoolObject Type>
class EmployeePool
{
public:
	static shared_ptr<EmployeePool<Type>> instance();

	shared_ptr<Type> hireEmployee();
	bool fireEmployee(shared_ptr<Type>& employee);
	size_t count() const { return pool.size(); }

	EmployeePool(const EmployeePool&) = delete;
	EmployeePool& operator =(const EmployeePool&) = delete;

private:
	vector<pair<bool, shared_ptr<Type>>> pool;

	EmployeePool() {}

	pair<bool, shared_ptr<Type>> createEmployee();

	template <typename Type>
	friend ostream& operator << (ostream& os, const EmployeePool<Type>& pl);
};

instance()

template <EmployeePoolObject Type>
shared_ptr<EmployeePool<Type>> EmployeePool<Type>::instance()
{
	static shared_ptr<EmployeePool<Type>> myInstance(new EmployeePool<Type>());

	return myInstance;
}

hireEmployee()

template <EmployeePoolObject Type>
shared_ptr<Type> EmployeePool<Type>::hireEmployee()
{
	size_t i;
	for (i = 0; i < pool.size() && pool[i].first; ++i);

	if (i < pool.size())
	{
		pool[i].first = true;
	}
	else
	{
		pool.push_back(createEmployee());
	}

	return pool[i].second;
}

fireEmployee()

template <EmployeePoolObject Type>
bool EmployeePool<Type>::fireEmployee(shared_ptr<Type>& employee)
{
	size_t i;
	for (i = 0; pool[i].second != employee && i < pool.size(); ++i);

	if (i == pool.size()) return false;

	employee.reset();
	pool[i].first = false;
	pool[i].second->clockIn();

	return true;
}

createEmployee()

template <EmployeePoolObject Type>
pair<bool, shared_ptr<Type>> EmployeePool<Type>::createEmployee()
{
	return { true, make_shared<Type>() };
}

operator <<

template <typename Type>
ostream& operator << (ostream& os, const EmployeePool<Type>& pl)
{
	for (auto elem : pl.pool)
		os << "{" << elem.first << ", 0x" << elem.second << "} ";

	return os;
}

# include <iostream>
# include <memory>
# include <iterator>
# include <vector>

using namespace std;

int main()
{
	shared_ptr<EmployeePool<Employee>> pool = EmployeePool<Employee>::instance();

	vector<shared_ptr<Employee>> vec(4);

	for (auto& elem : vec)
		elem = pool->hireEmployee();

	pool->fireEmployee(vec[1]);

	cout << *pool << endl;

	shared_ptr<Employee> ptr = pool->hireEmployee();
	vec[1] = pool->hireEmployee();

	cout << *pool << endl;
}