Newsgroup: it.comp.lang.c++
Titolo: membri statici in classi template

Ho incontrato un problema interessante...
Stavo giocherellando con classi template e oggetti statici quando ho 
scoperto che il mio compilatore non si comporta come mi aspetterei
(ma magari si comporta secondo lo standard :-)
Se abbiamo una classe con un membro statico, esso verra' costruito prima
dell'esecuzione della funzione main() e distrutto dopo. (E fin qui non ci 
sono problemi)
Mi aspetto che la stessa cosa succeda se la classe e' template (a meno di
avere un differente oggetto statico per ogni differente istanziazione del 
template). 
Il mio compilatore  (gcc-3.0) non la vede cosi'...
In particolare quello che succede e' che l'oggetto statico viene costruito
solo se qualcuno lo referenzia esplicitamente, e questo non e' proprio
quello che mi serviva. Si tratta di una "ottimizzazione" eccessiva ?
Cosa dice lo standard ? 
Come faccio a costringere il compilatore a farmi istanziare questi oggetti 
(i cui unici metodi sono proprio il costruttore e il distruttore) ?
Grazie per eventuali delucidazioni.
Fabio
==============================
-- 
Posted from 
flopiano.mm.eutelsat.org
 [194.214.173.28] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 (i cui unici metodi sono proprio il costruttore e il distruttore) ?
Assicurati che sia eseguito del codice che si trova nella stessa
translation unit in cui sono definiti.
--
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

 translation unit in cui sono definiti.
In realta' ho la necessita' che non venga eseguito esplicitamente alcun 
codice in quella translation unit. (l'oggetto in questione si occupa
di registrare la classe presso una factory).
 
Per il momento ho risolto inserendo l'oggetto statico dentro un 
namespace anonimo. (Dopo tutto e' a questo che servono, no ?)
ma questa soluzione non mi soddisfa pienamente...
Fabio


}
Puoi provare in questo modo (con gcc 2.95 funziona):
#include <iostream>
using namespace std;
class StaticObject
{
public:
 StaticObject() { std::cout << "Object Created" << std::endl; }
 ~StaticObject() { std::cout << "Object Deleted" << std::endl; }
};
template <typename T>
struct A { static StaticObject obj; };
template <typename T>
StaticObject A<T>::obj;
template  A<int>; // questa e` l'aggiunta
int main()
{
//        A<int> a;
}
ciao
Massimo

Cosa dice lo standard ? 
Che l'istanziazione implicita di un template non comporta
l'istanziazione implicita di nessuno membro dati statico
del template. In pratica il comportamento e' simile ai
*metodi* dei template, che vengono istanziati solo se qualcuno
vi fa riferimento (questa cosa e' importante per l'usabilita'
stessa dei template... ad esempio ci sono container template
che richiedono che gli elementi contenuti siano confrontabili
solo se tu chiedi cose come "sort"... se tutti i metodi
venissero istanziati anche se non riferiti la presenza di
un metodo "sort" - anche se non ti interessa - ti obbligherebbe
a definire un criterio di ordinamento sugli elementi contenuti).
La regola non vale per i membri non statici della classe
template. A livello filosofico questa e' secondo me una
stortura... ma praticamente diventerebbe molto difficile
riuscire a compilare un programma una compilation unit per
volta se si richiedesse che anche eventuali membri non
statici non riferiti non devono essere istanziati.
Nei documenti non ufficiali in mio possesso la regola per
i membri static e' descritta in 14.7.1 [temp.inst] con
esplicito riferimento al costruttore di membri statici:
  ... in particular, the initialization (and any
  associated side-effects) of a static data member
  does not occur unless the static data member is
  itself used in a way that requires the definition
  of the static data member to exist.
HTH
Andrea
--
Andrea Griffini, Programmer