Newsgroup: it.comp.lang.c++
Titolo: Metodi di una classe base non tutti pubblici.

   Salve a tutti...
Mi stavo ponendo un problema forse stupido, ma che mi piacerebbe risolvere 
nel modo piu` "elegante" possibile: qual e` il modo migliore per avere solo 
una parte dei metodi pubblici di una classe pubblicati in una sua derivata??
   Mi spiego meglio. Supponendo di avere una classe (chiamiamola base) da 
cui volerne derivare un'altra (chiamiamola derivata), come si puo` fare a 
far si che non tutti i metodi pubblici di base siano visibili all'esterno 
di derivata ???
   Io mi sono dato tre diverse possibili soluzioni, ma nessuna delle tre mi 
piace molto... Ve le elenco in ordine di (IMHO) "bellezza":
    1) Dichiarare una classe intermedia che faccia da "pubblicizzatore" dei
       metodi che mi interessano e poi usare quest'ultima per derivare tutte
       le altre... Una cosa del tipo:
<code>
class base {
public:
   int f1( void ); // Sono interessato a questa
   int f2( void );  // Ma non a questa
};
class intermedia : protected base {
public:
   int f1( void ) { return( this->base::f1() ); }
};
class derivata : public intermedia {};
</code>
       Non mi dispiace moltissimo, pero` si introducono troppi oggetti "in 
       per lo mezzo".
    2) Dichiarare privata la classe base nella classe derivata e poi
       (ri)costruire in derivata un insieme di metodi che reimplementino
       quelli di base che mi interessano. Una cosa, cioe`, del tipo:
<code>
class base {
public:
   int f1( void );  // Sono interessato a questa
   int f2( void );  // Ma non a questa
};
class derivata : private base {
public:
   inline int f1( void ) { return( this->base::f1() ); }
};
</code>
       Questa soluzione, che mi piace abbastanza, ha pero` il difetto che 
       ogni volta che cambio qualcosa in base devo andarlo a fare anche in
       tutte le sue derivate. Inoltre puo` diventare un incubo se i metodi
       da reimplementare sono troppi.
    3) Splittare la classe base in due sottoclassi ognuna con il suo
       sottoinsieme di metodi e ereditare in modo differenziato le due
       parti, cioe`:
<code>
class b1 {
public:
   int f1( void ); // Questa mi interessa
};
class b2 {
public:
   int f2( void ); // Questa no
};
class base : public b1, public b2 {};
class derivata : public b1, private b2 {};
</code>
       Quest'altra soluzione mi piace un po' meno, specialmente quando non
       sia banale dividere la classe base in due sottoclassi: magari ho
       bisogno dello stesso membro sia in b1 che in b2, anche questo puo`
       diventare un incubo, dovendo andare a derivare classi a destra e a
       manca.
   Che ne dite ??? Avevo anche pensato a cose piu` complesse usando 
derivate virtuali oppure classi di sola interfaccia, ma mi sembravano 
ancora piu` complesse come soluzioni.
                                  Spero & Accetto consigli
                                      Vax Headroom
-- 
                          |  
\|/ ____ \|/   \ ||_|     |  Tutti mentono; ma non importa, 
"@'/ ,. \`@"    \|| |     |  perche` nessuno sta a sentire.
/_| \__/ |_\ Vax Headroom |  
   \__U_/                 |          Legge di Lieberman


wrote:
<cut>
class base 
{
 blablablablablablablablablablablablabla
};
class derivata : protected base
{
	public:
		using base::metodopubblico;
};
così esponi solo i metodi che ti interessano
ciao
Antonio

 così esponi solo i metodi che ti interessano
   WOW !!! Credevo funzionasse solo con i namespace... Anche se avrei 
dovuto pensarci... Dopotutto una classe e` anche un namespace...
                                       Grazie millissime
