Le quantità ripetutamente calcolate derivate dai dati dei membri devono essere memorizzate nei contenitori dei dati dei membri?

Questa domanda riguarda generalmente quando è una buona idea memorizzare quantità derivate dai dati dei membri in, diciamo, std::vector s che saranno ripetutamente calcolate / accessibili in vari metodi, ma cercherò di illustrarle all'interno di uno specifico contesto.

Supponiamo che io abbia due classi come minimamente definite di seguito. La classe Configuration ha più metodi aggiuntivi che devono accedere alle quantità derivate dai dati dei membri di Particle oggetti. Ad esempio, in una simulazione, le posizioni delle particelle verranno aggiornate abbastanza frequentemente e questi metodi aggiuntivi necessiteranno del vettore di separazione tra particelle, calcolato con il metodo computeSeparationVector(...) di seguito.

È meglio in termini di prestazioni / efficienza chiamare ripetutamente questa funzione dai vari metodi che richiedono questa informazione, oppure è più performante calcolare questi dati una volta per ogni passaggio di aggiornamento e memorizzarlo, ad esempio, in std::vector<std::valarray<double>> separationVectors ? Se è quest'ultimo, qualsiasi suggerimento sui modi consigliati per archiviare tali dati sarebbe molto apprezzato.

Questo è ovviamente un esempio semplicistico, ma decidere se memorizzare o meno dati calcolati / derivati nei contenitori di dati dei membri è qualcosa a cui sono attualmente alle prese. Grazie!

#include <valarray>
#include <vector>

class Particle {
public:
    Particle(long index, double x, double y, double rad): 
        particleIndex(index),
        particleRadius(rad),
        xCoord(x),
        yCoord(y)
        { }

    const long particleIndex;
    double particleRadius;

    std::valarray<double> getCoords() {
        return {xCoord, yCoord};
    }

private:
    double xCoord;
    double yCoord;
};

class Configuration {
public:
    std::vector<Particle> particles;

    Particle getParticle(long particleIndex) const {
        return particles[particleIndex];
    }

    void addParticle(const Particle& particle) {
        particles.emplace_back(particle);
    }

    std::valarray<double> computeSeparationVector(long particle1Index, long particle2Index) const {
        return getParticle(particle1Index).getCoords() - getParticle(particle2Index).getCoords();
    }
};