Newsgroup: it.comp.lang.c++
Titolo: variabili statiche in una classe template

Nel codice:
   template <int ID>
   class A
   {
     static A instance;
   };
   typedef A<1> T;
   T T::instance;
Il compilatore si lamenta all'ultima riga:
too few template-parameter-lists
Ma come faccio a dare la definizione della variabile statica?
E.

    T T::instance;
Il problema e' che quella che stai scrivendo e' una specializzazione
implicita di A, nel senso che corrisponde a scrivere:
template <>
class A<1>
{
    static A<1> instance;
};
typedef A<1> T;
T T::instance;
Per poter omettere la specializzazione della classe devi scrivere:
template<>
A<1> A<1>::instance;
Ciao,
Nicola

> Ma come faccio a dare la definizione della variabile statica?
Io lascierei perdere il typedef e farei cosi':
template <>
A<1> A<1>::instance;
Ciao.

 implicita di A, nel senso che corrisponde a scrivere:
Uhm, questo vuol dire che probabilmente sto cercando di utilizzare i 
template dove non sono utili.
Per chi avesse voglia di leggere un po' più di codice provo a presentare 
il problema vero (che si rifà ad un thread precedente). Devo costruire 
una gerarchia di classi senza dati membro, con una unica istanza per 
ogni classe e con dei metodi virtuali. Inoltre per serializzare la 
classe assegno un identificatore intero ad ogni classe (tranne la base 
che è astratta) e definisco un costruttore virtuale. La classe TileType 
è la classe base astratta e la classe NormalTile è un esempio di classe 
derivata. Ora io vorrei poter definire velocemente questa gerarchia di 
classi senza dover riscrivere per ogni classe derivata i metodi per 
l'inizializzazione a la registrazione dell'unica istanza. Per far questo 
speravo di poter utilizzare i template, ma in effetti forse non sono 
utili in questo caso.
class TileType {
   protected:
   int the_id;
   typedef map<int,TileType *> registryT;
   TileType(int id); // l'utente non li può costruire
   static registryT &registry();
   public:
   static TileType* construct(int id); // costruttore virtuale
   int id() {return the_id;}; // ritorna un identificatore unico per la 
// serializzazione
   virtual void update(class Tile&) {};
   virtual void draw(class Tile&)=0;
};
TileType::registryT &TileType::registry() {
   static registryT theRegistry;
   return theRegistry;
}
TileType* TileType::construct(int id) {
   registryT::const_iterator f=registry().find(id);
   if (f==registry().end())
      throw runtime_error("TileType registry id not found");
   return f->second;
}
TileType::TileType(int id) {
    assert(registry().find(id)==registry().end());
    registry()[id]=this;
    cout<<"registering class id "<<id<<endl;
}
class NormalTile: public TileType {
   private:
     NormalTile(): TileType(1) {}; // per costruire l'unica istanza
   static NormalTile *init();
   public:
   static NormalTile *type; // questo è l'hook che utilizza l'utente
   virtual void update(Tile &);
   virtual void draw(Tile &);
};
NormalTile *NormalTile::type=NormalTile::init();
NormalTile *NormalTile::init() {
   static NormalTile theOnlyOne;
   return &theOnlyOne;
}

    T T::instance;
Ho letto la descrizione del problema che hai postato in un altro
messaggio, ma riprendo il discorso da qui. Questa mi pare una
soluzione ragionevole al problema che descrivi, ma purtroppo i membri
dati statici di classi template sono a mio avviso un po' un campo
minato. Questo funziona con svariati compilatori, ma non con g++
3.4.2:
#include <iostream>
#include <ostream>
template <int ID>
struct A {
    int f() { return ID; }
    static A instance;
};
template <int ID>
A<ID> A<ID>::instance;
int main() {
    std::cout << ( A<1>::instance.f() + A<2>::instance.f() ) << '\n';
}
Ciao,
Nicola

 ha scritto nel messaggio 
news:1176887122.0...@b75g2000hsg.googlegroups.com...


 e quindi di tutti i template, in questo caso, no ?
Ma dovrebbe essere condiviso da tutti i template con gli stessi 
parametri o da tutti i template con lo stesso nome?
E.

 e quindi di tutti i template, in questo caso, no ?
C'è un solo template in questo caso, quindi "di tutti i template" non
significa nulla. Ogni template ha potenzialmente infinite istanziazioni
possibili. Ognuna di queste è un tipo a sé stante, con i propri membri
statici, condivisi da tutte le istanze (oggetti) ma distinti da quelli
delle altre istanziazioni dello stesso template.
Max

azz che c...ta che ho detto, il sonno la faceva da padrone ...
Comunque i fatti stanno così :
Stroustup dice :
Each class generated from a class template gets a copy of each static
member of the class template (see §C.13.1).
Quind ogni classe istanziata da un template ha la sua bella copia del
membro static.....
Ciao.
"softwareEngineer" <free@__free__.it> ha scritto nel messaggio 
news:DFvVh.4646$jy5....@tornado.fastwebnet.it...
