Newsgroup: it.comp.lang.c++
Titolo: separare definizione da implementazione in una classe template. come?

ho scritto la dichiarazione della mia classe template in Classe.h:
template<class T>
class Classe {
    Classe();
    ~Classe();
    T* foo();
};
e in Classe.cpp:
#include "Classe.h"
template<class T>
Classe::Classe()
{
    ...
}
template<class T ... ecc...
ma il compilatore (MSVC 6) mi da questo errore:
use of class template requires template argument list
ma la template argument list non è "template<class T>" ?
ho cercato nei messaggi vecchi per vedere se trovavo un pezzo di codice per
risolvere al volo il problema, ma tutti mettono definizione e implementazione
insieme :(
ciao :: xaero



 }
ho letto il msg sotto al mio.
in Classe.cpp scrivo:
template<class T>
Classe<T>::Classe()
{ ... }
e il linker mi da 'unresolved external'

 ma la template argument list non è "template<class T>" ?
Due cose.
1) non puoi fare quello che vuoi. Il template deve stare tutto nell'header. A
meno che non usi una delle features aggiunte piu' di recente alo standard (la
funzionalità di export) che pero' non e' ancora supportata da quasi nessun
compilatore.
2) nonostante 1 l'errore si riferisce ad un'altra cosa. Ovvero l'errata sintassi
della tua definizione. L'unico caso in cui puoi usare Classe senza specifica e'
nel nome del costruttore. Quando 'Classe' non e' il nome del costruttore ma la
specifica di un tipo devi specificare la lista dei parametri dei template.
Quindi devi scrivere:
template<class T>
Classe<T>::Classe()
{
     ...
}
perche' il primo non e' il nome del costruttore ma quello della classe.
--
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

 e il linker mi da 'unresolved external'
Come ti ho già detto non devi scriverlo nel .cpp ma nel .hpp. L'implementazione
dei template deve essere visibile nel punto in cui la usi.


compilatore.
Quasi nessun compilatore? Io pensavo che non ci fosse nessun
compilatore che la supportasse
--
Marco Barisione (ICQ 84277092)

 compilatore che la supportasse
Nessuno che io sappia. Pero' non me la sento di giurarlo. Nel mondo opensource
ci sono sforzi in corso in questa direzione. Non vorrei che saltasse fuori
qualcuno a dire che la versione prealpha del compilatore XYZ contiene codice per
il supporto degli export.



Tu lo sai sicuramente, perchè frequenti comp.std.c++, ma se a qualcuno
interessa, la signature di Greg Comeau dice:
     Countdown to "export": December 10, 2001
Max

      Countdown to "export": December 10, 2001
Ci sono buone probabilità che il Comeau sia infatti il primo compilatore serio a
supportare efficacemente export. Pero' non si puo' mai dire.
In ogni caso ... come regalo di natale possiamo aspettarci di dover fare i
finanzieri: ovvero specificare che le esportazioni in area ISO sono IT e quelle
in area WIN sono OT.


 1) non puoi fare quello che vuoi. Il template deve stare tutto nell'header.
A
aaaaaaaah!... ecco che mi sfuggiva.
ecco perchè nessuno separa le due cose... :)
ciao :: xaero

 ha scritto nel messaggio
news:9mltc2$2v0th$1...@ID-51253.news.dfncis.de...

in attesa della implementazione di export ......
per i compilatori  Borland esistono __export e __import
che permettono la separazione dell' header dal codice.
Bisogna però definire manualmente nel modulo .cpp tutte le istanze
necessarie nel progetto
 (cosa che dovrebbe essere risolta automaticamente da export)
ad esempio :
template class __export  Couple<int,int>;
template class __export  Couple<double,char>;
....
io utilizzo una strategia di questo tipo:
alla fine del file cpp contenente il codice delle funzioni  membro template
inserisco:
#if defined(__BCPLUSPLUS__)
#  include "ExportTemplate.h"
#endif
dove in ExportTemplate.h  sono contenute le dichiarazioni di esportazione o
successivi include ad esse (progetti multipli)
non so se un analogo di  __export  sia presente in altri compilatori ma
penso che dovrebbe esserci qualcosa di simile.
----
Sergio Bianchi

 successivi include ad esse (progetti multipli)
Mi sa che stai confondendo operazioni specifiche dell'uso di DLL con la
gestione dei template.
Ciao,
Nicola

 ecco perchè nessuno separa le due cose... :)
Riprendo il suggerimento di Sergio Bianchi in termini piu' generali: E'
gia' possibile mantenere separate le dichiarazioni dei template dalle
loro implementazioni, a patto di istanziare esplicitamente *tutte* le
specializzazioni che ti servono. Ad esempio:
// file.h
template <typename T> T crea();
template <typename T> struct finta {
  finta();
  T t;
};
// file.cpp
template <typename T> T crea() { return T(); }
template <typename T> finta<T>::finta() : t(crea<T>()) {}
template int crea<int>();
template double crea<double>();
template class finta<int>;
template class finta<double>;
Ciao,
Nicola

 che permettono la separazione dell' header dal codice.
Per quello che ne so io __export e __import di borland e simili specificazione
in altri compilatori per Windows sono dei modificatori di linkage. Pertanto
servono per la creazione di DLL ma non esentano dall'avere i template
completamente definiti nel punto in cui vengono usati (e quindi negli header).
Non hanno nulla a che vedere con la funzionalità di export definita dallo
standard.


 ha scritto nel messaggio
news:3B8F6E83...@divalsim.it...

Sono andato a rivedermi da dove provenisse la mia curiosa convinzione
riguardo __export :
The declaration of a template function or template class needs to be
sufficiently flexible to allow it to be used in either a DLL or an EXE file.
The same template declaration should be available as an import and/or
export, or without a modifier. To be completely flexible, the header file
template declarations should not use __export or __import modifiers. This
allows the user to apply the appropriate modifier at the point of
instantiation depending on how the instantiation is to be used.
Il fatto che mi sia formato tale convinzione indica un urgente bisogno di
ferie. Cercherò di provvedere. Scusate lo svarione.
----
Sergio Bianchi