Newsgroup: it.comp.lang.c++
Titolo: Name Hiding in C++: perché?

Questo codice (in C#, ma andrebbe bene anche Java)
using System;
class M
{
    protected Object x;
    public M(Object j) { x=j; }
    public string GimmeJ() { return x.ToString(); }
    public string GimmeJ(int k) { return (string)(x.ToString()+k); }
};
class N : M
{
    public N(Object j) : base(j) {}
    public new string GimmeJ() { return (string)x.GetType().FullName; }
    public void niente() { return; }
};
public class Test
{
    public static void Main()
    {
        M mm = new M("Ciao");
        N nn = new N("Pippo");
        Console.WriteLine("M.GimmeJ č {0}",mm.GimmeJ());
        Console.WriteLine("M.GimmeJ(2) č {0}",mm.GimmeJ(2));
        Console.WriteLine("N.GimmeJ(2) č {0}",nn.GimmeJ());
        Console.WriteLine("N.GimmeJ(2) č {0}",nn.GimmeJ(2));
        Console.ReadLine();
    }
}
si compila e viene eseguito benissimo.
In C++, invece, l'override di GimmeJ automaticamente nasconde tutti gli
overload di GimmeJ nella classe base, in modo tale per cui N.GimmeJ(2) non
viene risolto.
Qualcuno mi aiuta a capire perché questa cosa accade in C++?

 Qualcuno mi aiuta a capire perché questa cosa accade in C++?
Per il piu' semplice dei motivi: perche' cosi' vuole il linguaggio. In C++ un
membro definito in una classe nasconde tutti i membri con lo stesso nome
definiti nelle classi base. Questo non accade in altri linguaggi come C#, Java,
Smalltalk etc.
Andrea Ferro
---------
Brainbench C++ Master. Scored higher than 97% of previous takers
Scores: Overall 4.46, Conceptual 5.0, Problem-Solving 5.0
More info 
http://www.brainbench.com/transcript.jsp?pid=2522556

Bella risposta. E' cosě perché č cosě!!! Ma dai!
Ci saranno dei motivi che hanno indotto Bjarne o chi per lui a fare questa
scelta. Vorrei capirli.
"Andrea Ferro" <And...@UrkaDVD.it> wrote in message
news:9aofp3$s95$1...@serv1.iunet.it...


 scelta. Vorrei capirli.
In pratica e' dovuto alle regole di overload resolution che in un linguaggio a
tipizzazione statica come il C++ sono diverse da quelle di un linguaggio a
tipizzazione dinamica. Nota per esempio che in C++ esistono i metodi non
virtuali, cosa che non puo' essere in un linguaggio a tipizzazione dinamica
pura. Pertanto in C++, per default, l'inserimento di un nome in uno scope
nasconde tutte le istanze di quel nome negli scope esterni in maniera che non
interferiscano con la semantica di overload del nome in quello scope. Il set di
funzioni in overload in un dato scope lo devi in pratica definire completamente.
Ovviamente se il nome non e' definito nello scope il lookup passa a eventuali
scope esterni. Ma se e' definito, allora tutte le funzioni in overload su quel
nome devono essere inserite in quello scope. Questo ti permette di avere
funzioni non virtuali, funzioni in uno scope non di classe (a livello di
namespace) e di realizzare l'overload degli operatori. Cioe' esattamente quelle
cose che non puoi fare in Java e altri linguaggi a tipizzazione dinamica.


Smalltalk etc.
si ma penso che lui si chiedesse perchè Stroustrup&C. hanno deciso di
fare così; e già che ci siamo me lo chiedo anche io, tanto più che le
funzioni "nascoste" non sembrano recuperabili in altro modo (ho
provato velocemente con using ma non ci sono riuscito; l'unico modo mi
sembra quello di definire esplicitamente una funzione nella derivata
che richiami quella della base, ma non è il massimo...)
Anto
--
Antonio Cuni, 18 anni, studente
Brainbench Certification: 
Master C++: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
http://www.brainbench.com/transcript.jsp?pid=1301688

 che richiami quella della base, ma non è il massimo...)
Infatti voleva dire quello. E gli ho risposto in un altro messaggio. Per quanto
riguarda using ... evidentemente il compilatore non e' del tutto conforme (o tu
non hai usato correttamente la using!).


 > Bella risposta. E' così perché è così!!! Ma dai!


 Delle due, propendo per la prima.
No, perche' da una parte manca una radice comune a tutti i tipi,
dall'altra RTTI e' troppo limitato. Sia che tu ti riferisca alla
tipizzazione statica, sia che tu ti riferisca al meccanismo di
risoluzione dell'overload e' una precisa volonta' semantica: il C, unico
possibile vincolo di compatibilita' all'indietro, non ha ne RTTI, ne
overload.
Ciao,
Nicola
-- 
Posted from 
mail.divalsim.it
 [194.185.113.194] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

non hai usato correttamente la using!).
struct base {
  void f() { }
  void f(int) { }
};
struct derived: base {
  void f() { }
  using base::f; // non funziona
  using base::f(int) // neanche
};
sbaglio io o il compilatore? Sullo Stroustrup non sono riuscito a
trovare dove ne parla...


 trovare dove ne parla...
Ovviamente il problema e' nel compilatore.


invece si.
bene, mi sento sollevato :-)
