Newsgroup: it.comp.lang.c++
Titolo: Derivare classi astratte

Salve , 
ho la necessita di derivare da una classe template  : 
template <class X,Y>class Base {
X t;
Y u;
X func(Y,int); ecc. ecc.
};
Ho provato a consultare un libro che ritenevo contenesse tutto sul c++
cioč il Herbert Schildt della McGraw Hill seconda edizione (un
mattone) ma non c'e' traccia di tale procedura .
com'č la sintassi  ?

 com'č la sintassi  ?
    class miaClasse: public Base<int, double> {
    // ecc ecc
Alex

 cioč il Herbert Schildt
Non č considerato un buon autore.
EMG



Grazie.

mattone)
Un altro povero albero sprecato! Sigh!
Paolo
p.s.
   La risposta te l'ha gia` data Alex...

 
altro problema: come si fa a passare parametri a Base nei costruttori di
Derivata:
template<class X, class Y> class Derivata : public Base<X,Y>
{
	...
public:
	Derivata (X a, Y b) : Base(a,b) { ... }
}
quel codice è corretto?
dunque... ho provato a compilarlo con egcs 112 e lo digerisce, dunque
suppongo di sì, il mio dubbio deriva dal fatto che le precedenti
versioni invece davano errore.
grazie, Simone

...

Il mio VC5 non ne vuole sapere di compilare quanto avete scritto.
Il minimo della sintassi per farlo passare mi risulta essere:
template <class X, class Y> class Base {
  X t;
  Y u;
  X func(Y,int) { return X(); }
};
template <class X, class Y> class Derivata : public Base<X,Y> {
public:
  Derivata (X a, Y b) : Base<X,Y>() {}
};
pero' non so quanto VC5 sia lontano dallo standard.
 Paolo Galassi

};
Una classe template non e' - come scritto nel subject - una classe
astratta.
Anche il tuo "Schildt", nel paragrafino riservato alle classi
astratte, scrive che una classe astratta non puo' essere istanziata, e
che puo' essere usata solo come classe base per qualche altra classe.
Questo non e' il caso delle classi template.
Una classe e' astratta se ha almeno una funzione virtuale pura.
  Paolo Galassi

astratta.
C'e' un errore nel subject.

 pero' non so quanto VC5 sia lontano dallo standard.
Abbastanza (e` di vari anni fa, dopo tutto), ma non
capisco questa particolare deviazione, ne` me la
ricordo da quando usavo VC++5.  Perche` mai dovrebbe
essere necessario al costruttore di Derivata invocare
esplicitamente quello di default di Base?!  Comunque
non ho piu` VC++5 in giro da un pezzo, quindi non
posso verificare.
Alex

 dunque... ho provato a compilarlo con egcs 112 e lo digerisce,
Mi sembra molto strano. A meno che non mi stia sbagliando io...
EMG

 Mi sembra molto strano. A meno che non mi stia sbagliando io...
ecco il codice che egcs 112 considera "sano"
-----------------------BEGIN----------------
template<class X, class Y>
	class base
	{
	public:
		X a;
		Y b;
		base (X x, Y y) : a(x), b(y) { }
	};
template<class X, class Y>
	class derivata : public base<X,Y>
	{
	public:
		int c;
		derivata (X h, Y i) : base(h,i) { }
	};
main ()
{
	base<int,double> a(0,-3.4);
	derivata<int,double> b(3,-5.6);
}

posso verificare.
Nemmeno sul VC++5 e' necessaria l'invocazione esplicita.
Non l'ho rimossa dal brano di codice per toccare il meno possibile
cio' che era scaturito dal thread.
Siccome non era stato definito il costruttore Base<X,Y>::Base(a,b),
avrei dovuto o aggiungerlo (come piu' giustamente ha fatto EMG,
assumendo che a e b dovessero essere passati alla base) o togliere i
parametri che comparivano nell'invocazione esplicita in
Derivata<X,Y>::Derivata(X a, Y b).  Cio' che volevo mettere in
evidenza era la necessita', in caso di invocazione esplicita del
costruttore della classe base, di ripetere la lista di argomenti
template <X,Y>.
  Paolo

  Paolo

Derivata < X, Y > ( X a, Y b ): Base < X, Y > ( a, b ) { ... }
^^^^^^^^
Non dovrebbe essere necessario....
Paolo

 }
Né Borland C++ 5.5 né DJGPP lo compilano.
EMG

derivata (X h, Y i) : base(h,i) { }
VC++5 vuole questa forma:
derivata (X h, Y i) : base<X,Y>(h,i) { }
  Paolo G.

 Non dovrebbe essere necessario....
Il < X, Y > dopo Derivata. Vero.
EMG