c ++: optimization of object set with freel list


I'm following the tutorial from the GameProgrammingPattern book. I tried to create a group of objects with it. I want to know how I can improve it. It is a fixed-size group, so there will be no increase or decrease in runtime in the group size.

Currency.h

#pragma once
class Coin
{
public:
    Coin();
    ~Coin();

    Coin* getNext() const { return CoinState.nextCoin; }
    void SetNext(Coin* nextActiveCoin) { CoinState.nextCoin = nextActiveCoin; }

    void Init(double _x, double _y, double _rotationSpeed);

    bool IsInUse() const { return CoinState.bIsInUse; };

    void Rotate();

private:

    union 
    {
        bool bIsInUse = false;
        struct a
        {
            double x, y;
            double rotationSpeed;
        }alive;

        Coin* nextCoin;
    }CoinState;

};

Coin.cpp

#include "Coin.h"
#include 
#include 
#include 

Coin::Coin()
{
}


Coin::~Coin()
{
    // destructor code here 
}

void Coin::Init(double _x, double _y, double _rotationSpeed)
{
    CoinState.alive.x = _x;
    CoinState.alive.y = _y;
    CoinState.alive.rotationSpeed = _rotationSpeed;
    CoinState.bIsInUse = true;std::cout << "Initializedn";
    //Rotate();
}

void Coin::Rotate()
{
    auto start = std::chrono::high_resolution_clock::now();
    //std::this_thread::sleep_for(std::chrono::seconds(3));

    while (1)
    {
        auto end = std::chrono::high_resolution_clock::now();
        std::chrono::duration elapsed = end - start;
        typedef std::chrono::duration float_seconds;
        int sec = 0;
        sec = std::chrono::duration_cast(elapsed).count();
        if (sec >= 5)
        {
            CoinState.bIsInUse = false;
            std::cout << "Deletedn";
            break;
        }
    }
}

CoinPool.h

#pragma once
#include "Coin.h"
class CoinPool
{
public:
    CoinPool();
    ~CoinPool();
    Coin* create();

    void Spawn(double x, double y, double rotationSpeed);
    void RepopulatePool();

private:
    static const int POOL_SIZE = 10000;
    Coin coins(POOL_SIZE);
    Coin* firstAvailableCoin;
};

CoinPool.cpp

#include "CoinPool.h"
#include 
#include 


CoinPool::CoinPool()
{
    firstAvailableCoin = &coins(0);

    for (size_t i = 0; i < POOL_SIZE - 1; ++i)
    {
        coins(i).SetNext(&coins(i + 1));
    }
    coins(POOL_SIZE - 1).SetNext(NULL);
}


CoinPool::~CoinPool()
{
    for (size_t i = 0; i < POOL_SIZE; ++i)
    {
        delete &coins(i);
    }
    delete firstAvailableCoin;
}

Coin* CoinPool::create()
{
    RepopulatePool();
    return firstAvailableCoin;
}

void CoinPool::Spawn(double x, double y, double rotationSpeed)
{
    assert(firstAvailableCoin != NULL);

    Coin* newCoin = firstAvailableCoin;
    firstAvailableCoin = newCoin->getNext();
    firstAvailableCoin->Init(x, y, rotationSpeed);
    RepopulatePool();
}

void CoinPool::RepopulatePool()
{
    for (size_t i = 0; i < POOL_SIZE; i++)
    {
        if (!coins(i).IsInUse())
        {
            coins(i).SetNext(firstAvailableCoin);
            firstAvailableCoin = &coins(i);
            return;
        }
    }

    std::cout << "Can't find unused coin";
}

I hope to see what I did wrong or can improve to improve the grouping and learn.
Thank you