Newsgroup: it.comp.lang.c++
Titolo: using ed overloading

Vi risulta che
class A {
  public:
    A() {}
    int M(int d1);
    int M(int d1, int d2);
};
class B: public A {
  public:
      B() {}
      using a::M;
      int M(int d1, int d2);
      int M(int, int, int);
};
sia legale?
Sapevo di si, ma gcc non lo accetta, se in B utilizzo la using non posso
eseguire l'overloading di M. Possibile che l'unica soluzione
sia aggiungere funzioni di forward in B?
Paolo
--------------------------------------------------
  Paolo Marotta
  Computer Science, University of Pisa
  home:   
http://www.cli.di.unipi.it/~marotta
--------------------------------------------------

E io che pensavo di conoscere il C++!
Mi diresti per favore a cosa serve la keyword using nel caso
che hai presentato?
Io pensavo che servisse solo per i namespace, ma in questo
caso non riesco a capirla. Grazie.
* Sent from AltaVista 
http://www.altavista.com
 Where you can also find related Web Pages, Images, Audios, Videos, News, and Shopping.  Smart is Beautiful

In attesa che Alex ci dia la conferma definitiva ti rispondo io :-)
La tua sintassi e' legale e quindi il problema e' del compilatore:
C++Builder ha lo stesso problema, ma solo all'interno dei template. Se
non sbaglio pero' la cosa dovrebbe funzionare anche se ti limiti a
dichiarare il membro ereditato riutilizzato, tipo:
class B: public A {
  public:
      B() {}
      A::M;
      int M(int d1, int d2);
      int M(int, int, int);
};
Un'altra cosa: ovviamente ti eri accorto di aver scritto
using a::M;
con la a minuscola invece di maiuscola...
Ciao,
Nicola

 caso non riesco a capirla. Grazie.
Una classe presenta parecchi aspetti di "namespace" (scoping
lessicale).
Normalmente, un nome dichiarato in una classe-derivata
NASCONDE lessicalmente lo stesso nome della classe-padre:
class base {
public: int pippo(int);
};
class derivata: public base {
public: int pippo(double);
};
int sorpresa(int xx)
{
    derivata deri;
    return deri.pippo(xx);
}
La "sorpresa(xx)" esegue derivata::pippo(xx), poiche` questa
nasconde lessicalmente base::pippo(int) e quindi il normale
meccanismo degli overload non si applica.  La soluzione:
class derivata: public base {
public:
    using base::pippo;
    int pippo(double);
};
In questo modo si usa nuovamente il normale meccanismo
degli overload (e deri.pippo(int) e` un match esatto quindi
viene usato in preferenza a deri.pippo(double)...!).
Alex

       A::M;
Questo non e` standard, ma tradizionalmente funzionava (era
un caso ad-hoc, mal documentato, ma implementato in molti
compilatori diffusi), quindi e` possibile in effetti che usandolo
si possa aggirare un qualche bug in merito di un particolare
compilatore (ma, attenzione!, solo a prezzo di incompatibilita`
con eventuali compilatori che invece seguano lo standard...).
Alex

       using a::M;
L'unico errore mi sembra questa a, che dovrebbe essere maiuscola.
Alex

 sia aggiungere funzioni di forward in B?
Sentiamo qualche parere più autorevole del mio...
EMG

L'unico errore mi sembra questa a, che dovrebbe essere maiuscola.
Si, in effetti e` un errore di battitura...
La domanda era nata perche` gcc non accetta tale sintassi, ed
io ricordavo invece che era prevista dallo standard...


using a::M;
Si... infatti nella prova che ho fatto avevo corretto l'errore, ma
evidentemente ho fatto un cut&paste dalla versione errata.


visibile?
B::M(int, int), in quanto la sua ridefinizione dovrebbe nascondere
quella di A::M(int, int) (ma non A::M(int))
