[c++]Template e opengl

[giuseppe500]

Ciao.
Sto realizzando un piccolo engine 3d per opengl.
Ogni elemento opengl ha una procedura per essere creato.
per es:
per creare una texture:

GLuint texture;
// alloco un identificativo
glGenTextures( 1, &texture );
//seleziono la texture corrente
glBindTexture( GL_TEXTURE_2D, texture );
glTexEnvf( GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,
                 GL_LINEAR_MIPMAP_NEAREST );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT );
glTexParameterf( GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT );
//e disegno qualcosa con la texture applicata

questa è la creazione molto semplice di una texture , chiaramente ci sono un enormità di parametri e combinazioni da gestire,ma alla fine per quel che devo fare sono un numero accettabile e comunque sul libro "templates the complete guide" sono spiegati i vari metodi di parametrizzazione dei template che sembrano funzionare ad hoc.

ho pensato infatti che delle classi template possono fare il lavoro di creazione e link della texture. per esempio con i vari parametri genero del codice che potrebbe essere in modo semplificato quello scritto sopra e questo a compile time.

Quello che non capisco è alla base : ho letto che i template agiscono solo a compile time e quindi : come una calsse template si comporta a runtime

se ho creato la texture con tutti i comandi c++ a compile time che potrebbe essere ad es:

CTexture<parametri>text;
text.create();//qui mi genera il codice a compile time

se aspetto ad es un risultato di un espressione runtime che non posso conoscere a compile time es:

if(f(x))//risorsa runtime{
    CTexture<parametri>text;
    text.create();//qui mi genera il codice a compile time
}

non viene generato tutto il codice di cui sopra?E quindi il senso dei template svanisce?
non riesco a capire.
Nella mia testa vedo il codice dei template espandersi quando viene chiamata la funzione template che crea la texture a compile time, ma non riesco a visualizzare il comportamento anche per un solo parametro runtime che non posso conoscere a compile time e quindi non riesco a capire quando avviene l'espansione del codice a runtime.

scusate se mi sono spiegato male , ma sono cose per me un po difficili , e non avendo ancora un modello mentale del soggetto abbastanza buono posso dire fesserie.
ciao.

[Who am I]

Se tu hai una classe come questa:

template <class T>
class C
{
private:
    T info;
public:
    C()
    {}   
};

Essendo T un tipo generico che può rappresentare un' infinità di tipi differenti, il codice per istanziare la classe non è ancora stato generato.
Dal momento che istanzi la classe in una qualche riga di codice:

C<int> c;

Quando lo compili viene creato il codice della classe sostituendo T con int.
Sarebbe come scrivere:

class C
{
private:
    int info;
public:
    C()
    {}   
};

Ma il codice del costruttore viene eseguito a runtime, non a compile time.
Viene creato a compile time sostituendo T con int.

[giuseppe500]

grazie,
il mio problema era diverso:
1)partivo dal dubbio sul perchè la metaprogrammazione è piu performante
qui ho un idea : la sostituzione non crea delle funzioni che vengono continuamente richiamate con relativo spreco di tempo in scrittura su stack delle variabili ecc.., bensi è un programma che scrive un programma(non l'ho detto io ma mi ha fatto pensare)e quindi vi è un espansione del codice ogni volta che instanzo una classe o richiamo una funzione template, questo è il concetto dell inline penso.
puo essere? chiedo

2)come fa essendo un meccanismo compile time a espandere una classe che ha informazioni che posso conoscere solo a runtime?

qui penso di aver capito:
è a compile time per quanto riguarda i tipi , in quanto in c++ a compile time quando scriviamo le classi e compiliamo scriviamo tipi, ma puo essere mischiata con il codice runtime ,ovvero: per quanto riguarda i tipi non c'è niente da fare , ed è per questo che secondo me i template non supportano il polimorfismo runtime, il tipo deve essere conosciuto , ma per quanto riguarda la logica dell'applicazione fatta ad es di

if(xxx==1)
{
    C<int>c
}
if(xxx==2)
{
    C<double>c
}
diverrà:
if(xxx==1)
{
    C<int>c espanso
}
if(xxx==2)
{
    C<double>c espanso
}

, questa puo essere mischiata con un espansione del codice runtime ovvero mantengo le cose logiche del codice ma le mischio con il codice generato dai template
Puo essere?

quindi sbagliavo nel concetto di runtime/compile time perchè quando si dice "i template sono un meccanismo compile time" riguarda la conoscenza o meno del tipo a compile time non della logica dell'applicazione e della possibilità di espandere o meno il codice questo se si conosce il tipo puo' sempre sessere espanso.

almeno penso.

[Who am I]

Non potendo sapere a compile time quale espressione sarà vera, a compile time verrà creato il codice del costruttore con T=int e con T=double.
Per farti capire come funziona il meccanismo dei template, guarda questo codice:

class A
{
};

template <class T>
bool foo(T item)
{
    return item>0;
}

int main(int argc, char** argv)
{
    return 0;
}

Nota che sulla classe A l' operatore '>' non è definito, eppure questo codice non da alcun errore di sintassi.
Supponiamo ora di cambiare il codice del main in questo modo:

int main(int argc, char** argv)
{
    A a;
    int b;
    cin >> b;
    if(b==5)
        foo(a);
    return 0;
}

Ora da errore di sintassi, perché sulla classe a l' operatore '>' non è definito, anche se a compile time il valore di b non è conosciuto perché dipende dall' input dell' utente.

[giuseppe500]

non riesco a capire:
il tuo codice da errore di compilazione sia che ci sia l'if sia no.
cosa cambia e cosa volevi dimostrare?
e cosa non ho capito?
questo è l'errore:
c:\open\open\core\temp\temp\temp.cpp(12): error C2676: binary '>' : 'A' does not define this operator or a conversion to a type acceptable to the predefined operator
1> c:\open\open\core\temp\temp\temp.cpp(21) : see reference to function template instantiation 'bool foo<A>(T)' being compiled
1> with
1> [
1> T=A
1> ]
grazie.

[Who am I]

Quello che ti volevo far capire è che l' errore di sintassi lo da anche per espressioni che verrebbero valutate a runtime.
Questo perché i template vengono espansi a compile-time e non sarebbe possibile prevedere il risultato di un if.
E' normale che ti da errore anche se non c'è l' if.
Ma l' errore non lo da se non invochi la foo da nessuna parte nel codice.

[giuseppe500]

grazie, scusa se ho posto dei dubbi, era perchè non avevo capito.
ciao.