Newsgroup: it.comp.lang.c++
Titolo: using?

class a {
	protected:
		void b();
};
class b : protected a {
	public:
		using a::b;
}
vorrei avere una informazione su using a::b;
utilizzando il compilatore borland c++ 5.0 ottengo
un errore se cerco di utilizzare b.... se invece lo ricompilo con il
borland c++ builder 4 funziona tranquillamente.
+ o - a partire da quando  using permette di cambiare la visibilità di
un membro di una classe base ? oppure a quale versione iso c++ mi
devo rifare xché ciò funzioni ? ... non vorrei che il codice che sto
scrivendo mi risulti inutile sul gcc 2.7.2 (mi pare anch'esso dello
stesso periodo del bc++ 5)
ho cercato sul libro di stroupstrup .. c++ 3za edizione ma non ho
trovato niente a riguardo ...
un'altra cosa.... é corretto usare using? vorrei solo dare visibilità
public a quei membri della classe base che mi interessano, nascondendo
quelli che magari riguardano un'altra classe derivata
Antonio

 stesso periodo del bc++ 5)
ti sconsiglio comunque di compilare con compilatori vecchi...
il borland c++ compiler e' arrivato alla versione 5.5.1 ed e' pure free.
Il gcc (altrettanto free) e' alla versione 3 e qualcosa.
--
Gerolamo

 All' unica versione dell'iso che esiste: ISO/IEC 14882
Questo è sacrosanto.
--
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

 Gerolamo "b" è sia il nome del metodo che quello della classe derivata).
il codice e' dell' OP...
Comunque e' un dubbio che era venuto anche a me, quando stavo
rispondendo che con lo using faceva casino con i nomi uguali, ma poi
mi sono reso conto che usava "using" nella maniera sbagliata...
...almeno secondo me... e cosi' non ho aggiunto nulla...
Giusto per la cronaca, col borland c++ 5.5.1 :
#include <iostream>
class a
{
    protected:
    void b()
    {
       std::cout << "Sono a::b()" << std::endl;
    };
};
class b : protected a
{
    public:
    b()
    {
        std::cout << "Sono il costruttore di b" << std::endl;
    }
    using a::b;
    void foo()
    {
        b();
    }
};
int main()
{
    std::cout << "Alloco un'istanza di b" << std::endl;
    b B;
    std::cout << std::endl << "invoco B.foo()" << std::endl;
    B.foo();
    std::cout << std::endl << "chiamo b()" << std::endl;
    b();
}
mi da questo out:
====
Alloco un'istanza di b
Sono il costruttore di b
invoco B.foo()
Sono a::b()
chiamo b()
Sono il costruttore di b
====
lascio i commenti agli esperti...
(modo elegante per dichiarare la propria ignoranza :-)
--
Gerolamo

Questo è sacrosanto.
voi dite di rifarmi all'unica versione iso che esiste ..... ma il
problema é un'altro...
quel frammento di codice che ho scritto ,avete scritto anche voi
sotto il bc 5.02 genera un errore...
class a {
	protected:
		void b();
};
class b: public a {
	public:
		using a::b;
};
b myb; myb.b();
genera un errore nel bc5.02 ... quindi potrei escludere i compilatori
che si aggirano attorno al 95/96 ......a partire da quale periodo di
tempo using a::b é valido?? 97? 98? 99? 
Antonio

 tempo using a::b é valido?? 97? 98? 99?
Se la domanda è quando il comitato ha cominciato a discuterne la
risposta è: non ne ho idea anche perchè lo sanno solo i membri del
comitato. Se la domanda è qual'è la data del primo draft che ne parlava
la risposta è ancora: non ne ho idea e anche questo lo sanno solo i
membri del comitato. Se la domanda è quale è stato il primo draft
*pubblico* a discuterne, la risposta è che credo proprio che fosse già
nel primo draft pubblico ma non so che data avesse.
Comunque credo che using sia comparsa contemporaneamente sia per l'uso
con i namespace che per l'uso con le classi.
In ogni modo fino a che lo standard non è stato pubblicato nella sua
versione definitiva qualunque cosa poteva essere aggiunta e qualunque
cosa poteva essere tolta. Alcuni compilatori riconoscevano bool nel '94.
Altri non lo hanno riconosciuto fino a molto ma molto più tardi. Fino
all'uscita dello standard non potevi comunque pretendere che un
compilatore fosse conforme (a cosa? Al draft che poteva cambiare? Fatica
inutile!).
Lo standard è stato pubblicato nel settembre del 98.
Significa che i compilatori usciti dopo supportano le features dello
standard? No di certo. Ad oggi NESSUN compilatore può dire di essere
100% standard.
Pertanto alla domanda "a partire da quando using a::b è valido" l'unica
risposta è: in termini di linguaggio a partire dal settembre 1998. Fino
a quel momento non esiteva il C++ (quello standard) e pertanto tutto e
niente era valido, in termini, invece, di compilatore, dal momento in
cui gli sviluppatori di quel compilatore lo hanno inserito. E non mi
stupirei troppo se qualcuno non lo avesse ancora inserito oggi.


100% standard.
ok grazie! :) questo mi é giŕ d'aiuto .. ora so con certezza che devo
sostituire la redhat che ho sul pc (la 4.2 :PP un pň vecchiotta..
mi serve x compilare sotto linux) con almeno la 6.. o la 6.1
vabbé, sul stroupstrup non trovavo riferimenti temporali ...
grazie ancora
Antonio