ciao.
Ho creato un meccanismo con i template in cui definisco un oggetto Data
codice:
Data<Tipo>
{
    Data(){
       m_data = new Tipo[size];
    }

    Tipo* GetDataAt(int at)
    {
        return m_data[at];
    }
    void SetData(int at, Tipo t)
    {
          m_data[at] = t;
    }
     
    Tipo* m_data;
}
e un oggetto Creator(con le policy class).
Infine ho una host class del tipo:
codice:
DataBuilder< Data<Tipo>, CreatorTexture>
{
    Data<Tipo> m_data;
    SetData(Data<Tipo> d)
    {
         m_data = d;
    }
    CreatorTexture::Type create()
    {
        return  CreatorTexture::Create<Data<Tipo> >(m_data));
    }
}
in questo modo posso creare a partire da un oggetto Data tutti gli oggetti specifici del tipo che mi interessa(template data) cambiando il creator.
Ho creato questa prova non per niente , ma per fare si che ci sia una separazione tra i dati e l'algoritmo, come nei function object , ma con la possibilità di personalizzarli e in un futuro utilizzare un oggetto (per es con tbb) di intel ereditando gli algoritmi dall'oggetto task e utilizzare un task sheduler.
Non tanto per la creazione dell' oggetto, quanto per calcoli e trasformazioni runtime.
Gestiro sempre:
Definizione dato -> trasformatore -> datoCreato -> trasformatore2 -> dato creato
saranno i trasformatori a ereditare da task.
Infondo ogni azione che eseguo su un dato è una trasformazione piu o meno complessa e quindi puo essere un task se scrivo il risultato localmente su di un oggetto e basta , per evitare tutti i casini del multithreading.

In pratica considerero' ogni oggetto un caso a se e ogni ogetto avra' degli oggetti data<Tipo> che verranno trasformati con il metodo delle policy class(con un "trasformatore") in qualcos altro , ma sempre un data<tipo> e cosi via.

ad es :

se ho un ogetto mesh(mesh1) con incapsulato un tipo data<vector3d>vertexes (un array di veritici)potro usare un trasformatore rotazione che ruota tutti i punti ad ogni ciclo(ho un ciclo infinito in un gioco per es) e scrive ogni ciclo l'oggetto data<vector3d>vertexesrotated sempre incapsulato nell' oggetto.
infine disegno i vertici dei triangoli ruotati (vertexesrotated )dopo la trasformazione ogni ciclo.
E questo puo essere fatto in parallelo con tuti gli altri oggetti mesh, oltre a mesh1.

mi(vi) chiedo se questo meccanismo possa essere fatto con i std::function, per non reinventare la ruota, perchè non li ho capiti bene.
ecc...