[C++] espandione template

[giuseppe500]

ciao.
Ho finalmente capito documentandomi su google l'uso dei container coi template , adesso ho un altro dubbio:
L'espansione di codice dei template avviene in modo statico in compile time.
Il mio problema è questo:
Ho una serie di oggetti beam,column,shell ecc.... che hanno tutti un metodo DrawGl da richiamare , questo metodo contiene del codice tipo:

        glBindVertexArray(m_vaoID[0]);
 
        glGenBuffers(2, m_vboID);
 
        glBindBuffer(GL_ARRAY_BUFFER, m_vboID[0]);
        glBufferData(GL_ARRAY_BUFFER, 9*sizeof(GLfloat), vert, GL_STATIC_DRAW);
        glVertexAttribPointer((GLuint)0, 3, GL_FLOAT, GL_FALSE, 0, 0); 
        glEnableVertexAttribArray(0);
 
        glBindBuffer(GL_ARRAY_BUFFER, m_vboID[1]);
        glBufferData(GL_ARRAY_BUFFER, 9*sizeof(GLfloat), col, GL_STATIC_DRAW);
        glVertexAttribPointer((GLuint)1, 3, GL_FLOAT, GL_FALSE, 0, 0);
        glEnableVertexAttribArray(1);
 
        // Second VAO setup     
        glBindVertexArray(m_vaoID[1]);
 
        glGenBuffers(1, &m_vboID[2]);
 
        glBindBuffer(GL_ARRAY_BUFFER, m_vboID[2]);
        glBufferData(GL_ARRAY_BUFFER, 9*sizeof(GLfloat), vert2, GL_STATIC_DRAW);
        glVertexAttribPointer((GLuint)0, 3, GL_FLOAT, GL_FALSE, 0, 0); 
        glEnableVertexAttribArray(0);
 
        glBindVertexArray(0);

ma se ho 10000 oggetti(e si parla proprio di 10000 oggetti) con una funzione drawgl simile a questa ma con alcune variazioni con i template viene espanso tutto il codice (è come se concatenassi tutto il codice delle varie funzioni di cui viene richiamato il metodo drawgl) e non uso funzioni virtuali?.
1)ma se avviene cosi ,solo con l'attributo inline posso fare una cosa del genere?
2)Devo fare un importazione da un tipo di formato input/output in xml e al tempo di compilazione non ho ancora gli oggetti, o meglio li ho senza i parametri per es:
questa è del codice che potrebbe essere espanso

   glBindBuffer(GL_ARRAY_BUFFER, m_vboID[1]);

ma mi manca il m_vboID[1],
è possibile espandere prima la funzione e poi dopo l'importazione andare a settare i vari parametri?
lavorano forse cosi i template?
Scusate ma non ho capito neanche su google.
Chiedo a voi.

Grazie in anticipo.

[giuseppe500]

l'espansione del codice dei template avviene solo in una fase che è quella della compilazione?
non c'è speranza?
quindi utilizzare i template in un applicazione "normale" dove si deve aspettare un evento o qualcosa che accada a seguito di una scelta dell' utente per es, non porta grandi vantaggi in velocità, il guandagno runtime è solo l'uso di funzioni che non sono virtuali ,che sono piu veloci?
o c'è qualciosa d'altro che mi sfugge?

grazie, scusate l'ignoranza ma non sono ancora riuscito a capire.

ciao.

[MItaly]

Originariamente inviato da giuseppe500
ma se ho 10000 oggetti(e si parla proprio di 10000 oggetti) con una funzione drawgl simile a questa ma con alcune variazioni con i template viene espanso tutto il codice (è come se concatenassi tutto il codice delle varie funzioni di cui viene richiamato il metodo drawgl)

Nessun compilatore è così stupido; il compilatore decide se fare inlining o meno in base alle dimensioni del codice che ne verrebbe fuori, e in base ai vantaggi dal punto di vista delle prestazioni che l'inlining potrebbe dare. Per un metodo così massivo (e "costoso", visto che sono tutte chiamate a funzioni "complicate" che probabilmente fanno addirittura trapping in kernel mode) dubito che il compilatore faccia inlining di alcunché - l'overhead di chiamata a funzione è ridicolo rispetto a quello che fa la funzione, per cui ci sono solo svantaggi nell'inlining (aumentano le dimensioni del codice e si sbidona l'i-cache).

e non uso funzioni virtuali?.

Se memorizzi puntatori e non oggetti le funzioni virtuali funzionano correttamente. Se invece il tipo memorizzato dal tuo container è la classe base di tutte queste varie classi (e non un puntatore ad essa) si incorre in object slicing, per cui tutti gli oggetti memorizzati "diventano" del tipo della classe base.
Ergo, se si vogliono memorizzare oggetti polimorfici in un container STL, nel 90% dei casi si devono memorizzare i puntatori ad essi.

1)ma se avviene cosi ,solo con l'attributo inline posso fare una cosa del genere?

Non ho capito... in ogni caso, nei compilatori moderni "inline" non ha praticamente influenza sull'inlining (la documentazione di VC++ dice addirittura esplicitamente che inline è completamente ignorato ai fini della decisione, visto che l'euristica usata dai compilatori per queste cose funziona molto meglio dell'intuizione dei programmatori), serve solo a consentire "deleghe" alla ODR.

2)Devo fare un importazione da un tipo di formato input/output in xml e al tempo di compilazione non ho ancora gli oggetti, o meglio li ho senza i parametri per es:
questa è del codice che potrebbe essere espanso

   glBindBuffer(GL_ARRAY_BUFFER, m_vboID[1]);

ma mi manca il m_vboID[1],
è possibile espandere prima la funzione e poi dopo l'importazione andare a settare i vari parametri?

Non ho capito/bis... non è che la funzione viene eseguita a compile-time, semplicemente il codice dei template viene espanso per il tipo specifico a compile-time, poi l'esecuzione avviene a runtime quando decidi tu di richiamare il metodo in questione, ovvero quando si spera che m_vboID sia stato correttamente inizializzato.

l'espansione del codice dei template avviene solo in una fase che è quella della compilazione?

L'espansione sì, l'esecuzione ovviamente a runtime...

non c'è speranza?
quindi utilizzare i template in un applicazione "normale" dove si deve aspettare un evento o qualcosa che accada a seguito di una scelta dell' utente per es, non porta grandi vantaggi in velocità, il guandagno runtime è solo l'uso di funzioni che non sono virtuali ,che sono piu veloci?

Eh?

o c'è qualciosa d'altro che mi sfugge?

Onestamente, mi sembra che tu abbia capito cose molto strane... un template è semplicemente un generatore di codice, è un po' come se fosse una macro all'ennesima potenza. Quando tu istanzi un template è un po' come se il compilatore facesse copia-incolla del codice del template sostituendo i parametri template che hai specificato; poi per il resto l'esecuzione del codice avviene normalmente.

[giuseppe500]

Originariamente inviato da MItaly
Nessun compilatore è così stupido; il compilatore decide se fare inlining o meno in base alle dimensioni del codice che ne verrebbe fuori, e in base ai vantaggi dal punto di vista delle prestazioni che l'inlining potrebbe dare. Per un metodo così massivo (e "costoso", visto che sono tutte chiamate a funzioni "complicate" che probabilmente fanno addirittura trapping in kernel mode) dubito che il compilatore faccia inlining di alcunché - l'overhead di chiamata a funzione è ridicolo rispetto a quello che fa la funzione, per cui ci sono solo svantaggi nell'inlining (aumentano le dimensioni del codice e si sbidona l'i-cache).

Se memorizzi puntatori e non oggetti le funzioni virtuali funzionano correttamente. Se invece il tipo memorizzato dal tuo container è la classe base di tutte queste varie classi (e non un puntatore ad essa) si incorre in object slicing, per cui tutti gli oggetti memorizzati "diventano" del tipo della classe base.
Ergo, se si vogliono memorizzare oggetti polimorfici in un container STL, nel 90% dei casi si devono memorizzare i puntatori ad essi.

Non ho capito... in ogni caso, nei compilatori moderni "inline" non ha praticamente influenza sull'inlining (la documentazione di VC++ dice addirittura esplicitamente che inline è completamente ignorato ai fini della decisione, visto che l'euristica usata dai compilatori per queste cose funziona molto meglio dell'intuizione dei programmatori), serve solo a consentire "deleghe" alla ODR.

Non ho capito/bis... non è che la funzione viene eseguita a compile-time, semplicemente il codice dei template viene espanso per il tipo specifico a compile-time, poi l'esecuzione avviene a runtime quando decidi tu di richiamare il metodo in questione, ovvero quando si spera che m_vboID sia stato correttamente inizializzato.

L'espansione sì, l'esecuzione ovviamente a runtime...

Eh?

Onestamente, mi sembra che tu abbia capito cose molto strane... un template è semplicemente un generatore di codice, è un po' come se fosse una macro all'ennesima potenza. Quando tu istanzi un template è un po' come se il compilatore facesse copia-incolla del codice del template sostituendo i parametri template che hai specificato; poi per il resto l'esecuzione del codice avviene normalmente.

grazie Mitaly.
Ho letto con attenzione i tuoi aiuti!
praticamente , quello su cui facevo confusione io è che avevo compreso un mix tra runtime e compile time sull'espansione del codice.
come se quello che avvenisse a runtime ,potesse modificare il template e l'espansione del codice, ma ho pensato che l template si basano sul tipo(forse dico una xxx),e il tipo non cambia a runtime , quindi tutte le espansioni non sono che come dici tu semplificando una spece di macro che espande il codice in base a parametri che sono tipi o "tipi primitivi".
infatti il polimorfismo a runtime non si puo fare coi template, ecco forse la ragione o una delle ragioni
grazie 1000 , penso davvero di aver capito