Qual è la soluzione migliore per l'allocazione della memoria statica?

Sto lavorando all'elaborazione delle immagini e ho bisogno di usare immagini grandi in un sistema critico.

Una buona pratica per i sistemi critici è quella di evitare l'allocazione dinamica della memoria, ma qual è il progetto / i consigli per l'allocazione della memoria statica?

Se eseguiamo un'allocazione statica di una grande matrice, otteniamo un overflow dello stack.

class test
{
    public:
        test(){};
        ~test(){};

    private:
        float m_bigMatrix[3000000];
};

Per risolvere questo problema possiamo definire la matrice come statica, ma questa matrice sarà la stessa per tutte le istanze di questa classe.

static float m_bigMatrix[3000000];

L'altra soluzione è avere un oggetto statico.

static test t;

Ho una soluzione da un altro forum in cui è stato suggerito che il l'approccio migliore sarebbe utilizzare una classe specifica per la gestione della memoria.

Tutte le istanze della classe sono statiche e vengono utilizzate da altre classi nel codice.

Ecco una versione sciatta per questa soluzione (è solo un esempio):

class MemManager
{
public:
    MemManager(){ m_counter = 0u; }
    ~MemManager(){ printf("Out of MemManager nbr %d\n", m_counter); }

    uint16_t getCounter() { return m_counter; }
    uint16_t getData(uint32_t pos) { return m_data[pos]; }

    void setCounter(uint16_t val) { m_counter = val; }
    void setData(uint16_t val, uint32_t pos) { m_data[pos] = val; }

private:
    static const uint32_t MEM_SIZE_DATA = 100000000u;
    uint16_t m_counter;
    uint16_t m_data[MEM_SIZE_DATA];

protected:
};

class MemUser
{
public:
    MemUser(){ m_memManager = NULL; }
    ~MemUser(){ printf("Out of MemUser\n"); }

    void init(MemManager& memManager) { m_memManager = &memManager; };
    uint16_t getCounter() { return m_memManager->getCounter(); }
    uint16_t getData(uint32_t pos) { return m_memManager->getData(pos); }

    void setCounter(uint16_t val) { m_memManager->setCounter(val); }
    void setData(uint16_t val, uint32_t pos) { m_memManager->setData(val, pos); }

private:
    MemManager *m_memManager;

protected:
};

int main()
{
    static MemManager mManager;
    mManager.setCounter(1);
    {
        MemUser mUser;
        mUser.init(mManager);
        printf("Exit scope\n");
    }
    for(uint8_t i = 1u; i<5u; i++)
    {
        static MemManager mManager2;
        printf("Note that mManager2 is the same: %d\n", mManager2.getCounter());
        mManager2.setCounter(i);
    }
    printf("Exit process\n");
    return 0;
}

Quindi, è corretto? Qual è la soluzione migliore?