Newsgroup: it.comp.lang.c++
Titolo: using e membri statici di una classe

Ho il seguente programma:
class foo
{
   protected:
     static int do_foo(int i) { return i += 1; }
};
class silly: public foo
{
   public:
     using foo::do_foo;
};
#include <iostream>
int main()
{
   silly s;
   std::cout << s.do_foo(5) << '\n';
   std::cout << silly::do_foo(5) << '\n';
}
La chiamata silly::do_foo mi causa un errore (con il BCC 5.5):
Error: 'foo::do_foo(int)' is not accessible in function main()
Con il DJGPP compila senza problemi.
Che dice lo Standard?
Grazie  Manlio Perillo

Credo abbia ragione il BCC 5.5, una classe derivata puo` restringere
i privilegi di accesso alle funzioni membro di classe base (pubblice e
protette), ma non puo` rilasciarli (violerebbe l'incapsulazione).
Paolo

 alle funzioni membro di classe base (pubblice e protette)
?
Grazie   Manlio Perillo

protette), ma non puo` rilasciarli (violerebbe l'incapsulazione).
Purtroppo no... quella che chiami "violazione dell'incapsulazione"
puo' essere ritenuta immorale ma sicuramente non e' illegale.
In altre parole una volta che ti fidi di una classe dando il permesso
a questa di fare qualcosa non puoi impedire che questa classe dia
questa capacita' al mondo intero (personalmente la trovo una cosa
giusta... in fondo che differenza farebbe rispetto ad una classe con
una funzione pubblica che semplicemente rimappa la funzione che
io volevo protetta ?).
"The C++ Programming Language" 3^ edizione descrive questo tipo di
utilizzo al paragrafo 15.3.2.2.
La mia opinione e' che si tratti di un bug del BCC55 (non vedo perche'
dovrebbero esistere regole particolari per le static).
Andrea
--
Andrea Griffini, Programmer
http://www.netservers.com/~agriff

?
Se derivi privatamente (o protected), i metodi pubblici e protetti
(solo pubblici) vanno a far parte della sezione private (protected)
della classe derivata. Per renderli pubblici dovresti in tal caso
esportarli esplicitamente.
Paolo

puo' essere ritenuta immorale ma sicuramente non e' illegale.
Mi sorge il dubbio di non aver letto bene il codice di esempio.
Appena posso provo a ripescarlo ed eventualmente a
rimediare alla mia distrazione.
Paolo


Già, mi era proprio sfuggito di mente.
Manlio Perillo


Non riesco a mandarti il messaggio via mail.
Quindi ti posto il codice qui.
class foo
{
   protected:
      static int do_foo(int i) { return i += 1; }
};
class silly: public foo
{
   public:
      using foo::do_foo;
};
#include <iostream>
int main()
{
   silly s;
   std::cout << s.do_foo(5) << '\n';       // <== funziona
   std::cout << silly::do_foo(5) << '\n';  // <== non funziona
}
Saluti   Manlio Perillo

   std::cout << silly::do_foo(5) << '\n';  // <== non funziona
Che io sappia nessuna delle due dovrebbe funzionare,
quando usi la using nella classe derivata il compilatore
dovrebbe arrabbiarsi.
Paolo


Strano, che io sapessi lo "static" non dovrebbe cambiare le cose,
non dovrebbe essere possibile rilasciare i diritti. In pratica
il compilatore dovrebbe segnalare errore in entrambi i casi (VC non lo
fa).
Paolo


Il VC dovrebbe aver ragione ed il BCC avere qualcosa che non va.
Manlio Perillo

E' descritta dallo Stroustrup.
Devo comprare la terza edizione...
Dove sta scritto cosi` vado a vedere...
Paolo

 E' descritta dallo Stroustrup.
Copio da 15.3.2.2
A using-declaration cannot be used to gain access to additional
information. It is simply a mechanism for makin accessible information
more conveniente to use. On the other hand, once access is available, it
can be granted to other users.
E quindi dovrebbe funzionare (se ci fossero state dell'eccezioni penso che
le avrebbe menzionate). Il VC++ 6.0 lo compila, e del resto non vedo che
differenza ci sia tra s.do_foo(5) e silly::do_foo(5).
Quello che non sapevo è che si potesse chiamare una funzione statica
attraverso un oggetto della sua classe, e mi chiedo, è standard?
Ciao Fulvio.

attraverso un oggetto della sua classe, e mi chiedo, č standard?
Si, e` la stessa cosa, solo che in realta` l'oggetto non serve poiche`
non c'e` un "this" da passare al metodo.
Paolo

 l'incapsulamento?
No. Se una classe base dichiara delle funzioni protected significa
che le vuole rendere accessibili alle classi derivate.
Potrei quindi fare (nel mio esempio):
class foo
{
   protected:
      int do_foo(int i) { return i += 1; }
};
class silly: public foo
{
   public:
      int do_foo(int i) { return foo::do_foo(i); };
};
Con using foo::do_foo la cosa è più semplice, più chiara e più
comoda (importa tutte le eventuali funzioni f overloaded)
Comunque attendo ancora un parere definitivo per
sapere se il comportamento del BCC 5.5 è un BUG.
Manlio Perillo

Potrei quindi fare (nel mio esempio):
[cut]
Effettivamente da questo punto di vista hai ragione...
Paolo