Newsgroup: it.comp.lang.c++
Titolo: private e const

ho un problema e non so se dipende da vc6 o da me
una classe ha 2 metodi identici a meno di const:
class A
{
    int r;
private:
    int&get_r () { return r; }
public:
    const int &get_r () const { return r; }
}
ora se da codice esterno ad A invoco get_r come in questo caso:
A a;
a.get_r();
ottengo errore di accesso a metodo privato. io sapevo/pensavo che anche su
oggetti non const, invocando un metodo quale get_r, venisse chiamata la
versione const pubblica piuttosto che generare errore di invocazione di
metodo privato.
com'e' la questione?
grazie a tutti
Touch

io sapevo che solo oggetti costanti posso essere 
oggetto di invocazione di funzioni costanti,
il tuo compilatore chiama automaticamente la funzione privata perche' 
sa che la pubblica ha come oggetto di invocazione un A non costante.
CREDO SIA COSI NN SONO UN ESPERTO
ciao
-- 
Posted from 
ppp-62-10-170-71.dialup.tiscali.it
 [62.10.170.71] 
via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 metodo privato.
Se l'oggetto è non const viene cercato il metodo non const. Solo se
questo non esiste o è nascosto (nascosto non è la stessa cosa di non
accessibile) viene chiamato un eventuale metodo const topo aver
convertito l'oggetto in costante.
--
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

 accessibile)
cosa si intende per nascosto?
bye
Touch

 wrote in message
news:9v9ntf$4034$1...@stargate1.inet.it...

In inglese hidden. Quando la signature non è visibile in quanto altre
signature con lo stesso nome sono presenti ad un successivo livello di
annidiazione. La signature non visibile potrebbe essere comunque
accedibile (per esempio con uno scope operator o tramite using).
Un esempio:
class B {
public:
    void foo( char* ) {}
    void foo( char ) {}
    void foo( long ) {}
    void foo( double ) {}
    void bar()
    {
        foo( '2' );    // chiama  B::foo(char)
        foo( 2.F );    // chiama  B::foo(double)
        B::foo( 2.F ); // chiama  B::foo(double)
    }
};
class D1 : public B {
public:
    void foo( int ) {}
    void foo( float ) {}
    void bar()
    {
        foo( '2' );    // chiama D1::foo(int)
        foo( 2.F );    // chiama D1::foo(float)
        B::foo( 2.F ); // chiama  B::foo(double)
    }
};
class D2 : public B {
public:
    using B::foo;
    void foo( int ) {}
    void foo( float ) {}
    void bar()
    {
        foo( '2' );    // chiama  B::foo(char)
        foo( 2.F );    // chiama D2::foo(float)
        B::foo( 2.F ); // chiama  B::foo(double)
    }
};


 a.get_r();
quando il compilatore vede questa riga esegue queste operazioni:
- cerca tutte le funzioni di nome get_r all'interno dello scope di A.
- a questo punto effettua la risoluzione dell'overload
- se trova un'ambiguita' stampa un messaggio di errore. In questo caso 
non c'e' ambiguita' e il compilatore sceglie la versione non-const.
- altrimenti, se non c'e' ambiguita', controlla la specifica di accesso 
per l'unica funzione che ha scelto. In questo caso l'unica specifica di 
accesso accettabile e' pubblic. Ma dato che la versione non-const da 
lui scelta e' private segnala un errore.
ciao Anto
-- 
Antonio Cuni, 19 anni, studente
Brainbench C++ Master: 4.6, higher than 98% of all previous test takers.
C Language: 3.32, higher than 79% of all previous test takers.
Guida C/C++ di Programmazione.it: 
http://cpp.programmazione.it