Newsgroup: it.comp.lang.c++
Titolo: Perchè non funziona? (Errore interno del complilatore)

Ho queste righe di codice in un file .H, uso il VC++ del Visual studio 6.0
------------------
// Ordinamento generico
enum DirOrd { ASC=0, DISC };
template <class T>
class Ord
{ public:
 Ord(DirOrd di = ASC) {vdirOrd = di;} // costruttore
// Restituisce la direzione di ordinamento
 DirOrd dirOrd() const {return vdirOrd;}
// Operatore di confronto
 virtual bool precede(const T& a1, const T& a2) const
 { return (dirOrd() == ASC) ? a1 < a2 : a2 < a1; }
// Operatore di uguaglianza derivato da precede
 bool uguale(const T& a1, const T& a2) const
 { return !precede(a1,a2) && !precede(a2,a1); }
// Modifica la direzione di ordinamento
 void modDirOrd() { vdirOrd = (dirOrd() == ASC) ? DISC : ASC; }
// Ordinamento di default definito come costante statica
 const static Ord def;
 private:
 DirOrd vdirOrd;
};
template <class T>
const Ord<T> Ord<T>::def = Ord<T>(); // Ordinamento di default
// Funzione di minimo e di massimo generica
template <class T> inline
T min(const T& a1, const T& a2, const Ord<T>& o = Ord<T>::def)
{ return (o.precede(a1, a2)) ? a2 : a1; }
--------------------------
La complilazione fallisce quando deve compilare la funzione min.
Dice che c'è stato un errore interno del compilatore...
Come si fa a inizializzare un valore static di una classe senza che mi dia
errore???
--
| /
| \Byte - Andrea Briganti
E-Mail 
kbyt...@freemail.it
ICQ 40872731

Effettivamento non compila, č proprio un rozzo di compilatore. Ho provato in
tutti i modi, ma l'unico modo che mi č riuscito per farglielo compilare č
usando direttamente il costruttore di defaul:
template <class T> inline
T min(const T& a1, const T& a2, const Ord<T>& o = Ord<T>())
{ return (o.precede(a1, a2)) ? a2 : a1; }
e poi bisogna addirittura scrivergli due costruttori perchč altrimenti non
compila ancora:
Ord() {vdirOrd = ASC;}
Ord(DirOrd di) {vdirOrd = di;}
La domanda vera perņ č un'altra: c'č qualche errore nel codice o č colpa del
compilatore?
Io di errori non ne ho visti. Il problema probabilmente sorge dal fatto che il
compilatore genera un oggetto static def per ogni classe che genera (ci sarą
un Ord<int>::def , un Ord<double>::def, un Ord<MyClass>::def etc.). Genera
perņ solo le classi di cui ha bisogno (se non utilizzi mai un oggetto Ord<int>
non crea nemmeno Ord<int>::def) e quindi non č in grado di garantire che per
ogni parametro passato esista l'implementazione del codice della classe
(min(ClasseSconosciuta(), ClasseSconosciuta()) č difficile da gestire se non
costruisci un oggetto Ord<ClasseSconosciuta>).
Sarebbe interessante sapere se qualche compilatore riesce ha compilarlo, io ho
provato il VC++ 5.0 e il 6.0 senza service pack, e non funziona.
Ciao FBF.

 Sarebbe interessante sapere se qualche compilatore riesce ha compilarlo,
io
Qualcuno ha provato???


 Qualcuno ha provato???
Con egcs 1.2:
[nota: in prova.c:7 viene usata min<int>(...)]
prova.c: In instantiation of `Ord<int>':
prova.c:7:   instantiated from here
prova.c:7: aggregate `class Ord<int> const Ord<int>::def' has
           incomplete type and cannot be initialized
prova.h: In instantiation of `Ord<int>::def':
prova.c:7:   instantiated from here
prova.h:37: confused by earlier errors, bailing out
Ho provato una versione senza template, praticamente uguale
ma con  `typedef int T'  al posto di  `template<...>':
compila senza errori (e senza warnign), anche se poi mi dice
che min(3, 4) == 4.
	Mauro