Newsgroup: it.comp.lang.c++
Titolo: indirizzo da funzione

Salve a tutti,
traccio un esempio:
class alfa {
int a;
int b;
}
ho una funzione che restituisce un indirizzo alla classe alfa, facciamo:
alfa* funzioneprova()
vorrei assegnare un valore al membro b tramite l'indirizzo fornitomi da
funzioneprova.
E' possibile far questo?
dovrei scrivere una cosa tipo
funzioneprova()->b=10
E' giusto oppure magari il compilatore non mi da errore sintattici ma
capisce fischi per fiaschi? :-)
grazie per l'attenzione
ivan

 ivan
    sbirish

"sbirish" <sbi...@dontspam.me.tnx> wrote in message
news:Aye0a.137683$0v.38...@news1.tin.it...
magari due void ci stavan bene

 }
Meglio:
class Alfa {
public:
    void set_a( int _a ) { a_ = _a; }
    int get_a( void ) { return a_; }
    void set_b( int _b ) { b_ = _b; }
    int get_b( void ) { return b_; }
};
Da cui:
int main( int _argc, char * _argv[]) {
    auto_ptr< Alfa > myalfa;
    myalfa = CreateAlfa( );
    myalfa->set_a( 10 );
    return 0;
}
Ciao
Azathot

     myalfa = CreateAlfa( ); // Stiamo evitando un memory leak!!!
si un memory leak....
mi son dimenticato un bel delete anche hihi
non ha cmq senso avere una CreateAlfa simile..
posso capire se fosse un factory..
ne tantomeno aveva senso l'esempio :)
cmq il memory leak è inesistente :)
siamo nella main.. l'oggetto viene distrutto cmq..
visto che usciti dalla main *puff* processo scomparso :)
hihi l'autoptr in un esempio di tale stupidita' ed inefficacia
credo sia un gran spreco =)
scusa ancora le vaccate che ho scritto :)
perché hai il vizio di usare una marea di _ prefissi? :)
ciao
    Sbirish

 perché hai il vizio di usare una marea di _ prefissi? :)
Perché a vista si distinguono e perché posso dare lo stesso nome alle cose
ma distinguerne la visibilità/ciclo di vita. Esempio:
_text => Testo (parametro)
text => Testo (copia locale)
text_ => Testo (attributo della classe)
Quindi scrivo:
string ToUppercase( const string& _text ) {
    string text( _text );
    for( int p = 0; p < text.size(); ++p )
        text[ p ] = toupper( text[ p ] );
    return text;
}
Ciao!
Azathot

"sbirish" <sbi...@dontspam.me.tnx> ha scritto nel messaggio
news:Aye0a.137683$0v.38...@news1.tin.it...
grazie a entrambi ma avevo già risolto con una public.
cercavo più che altro uan conferma!
ivan

}
chiarissimo.. io avrei scritto:
string toUppercase ( const string& text )
{
    string temp( text );
    int textsize=text.size();
    for( int c=0; c!= textsize; c++)
        // si.. abitudine sbagliata.. c++ invece di ++c :) ... sono un
traviato dal C =)
        // qui mi va bene visto che e' un int :)
        // se fosse stato altro.. come un iterator
        // avrei.. sgarrato
        // sembri molto attento a quello che scrivi :) anche per il 'work on
temp'
    ....
}
in genere cmq uso come convenzioni..
MyClass
myMethod
mymember_
myinstance
ciau
    Sbi


Non mettere mai inutilmente dati membro pubblici.
Utilizza Get e Set come ti e' stato giustamente suggerito, altrimenti ci
prendi la mano con queste cattive abitudini.
Maurus

 text_ => Testo (attributo della classe)
Pero' corri il rischio di entrare in conflitto con nomi riservati
all'implementazione. Al tuo posto eviterei l'underscore prefisso.
In secondo luogo mi pare pericoloso utilizzare in uno stesso contesso
nomi che differiscono cosi' poco. Il rischio di errori e' alto.
Ciao,
Nicola

 nomi che differiscono cosi' poco. Il rischio di errori e' alto.
Nessun errore: essi mantengono ESATTAMENTE la stessa informazione, solo
con ciclo di vita/visibilitą diverso. Se utilizzassi "text" per indicare
qualcosa di diverso da "_text" avresti ragione.
Ciao!
Azathot

 wrote
La convenzione usata da me (e' simile a quella microsoft) e':
m_variabile per le variabili membro di una classe
variabile per le altre.
Tommy

 variabile per le altre.
Questione di convenzione, comunque il fatto che sia simile a quella
microsoft non depone a suo favore. <g>
L'unica mia perplessità è che una variabile che inizi per "m_" non la potrai
mai avere...
Ciao!
Azathot

 qualcosa di diverso da "_text" avresti ragione.
Pero' se scrivi qualcosa come
void C::f(std::string & _text) {
  // ops! volevo modificare il membro dato:
  //  text_ = _text + ".cpp";
  _text = _text + ".cpp";
}
visivamente non si nota ed il compilatore non ti aiuta.
Ciao,
Nicola

 mai avere...
A che cosa ti servirebbe?!?
Tommy

 visivamente non si nota ed il compilatore non ti aiuta.
Non mi sembra un caso frequente: se devo modificare il membro dato, _text
dovrebbe essere dichiarato come "const string& _text", dato che _text non
dovrebbe essere necessario modificarlo. D'altro canto se quello che hai
scritto è giusto, allora ad essere sbagliato è la dicitura "text" del
parametro: evidentemente il parametro ha un'altra funzione IN PIU'
rispetto alla semplice modifica del dato membro.
Ciao!
Azathot

 }
una domanda: non e' sconsigliato usare l'underscore prefisso, in quanto 
potrebbero essere keyword riservate alla lib e al compilatore?

 potrebbero essere keyword riservate alla lib e al compilatore?
Gli identificatori che iniziano con un underscore sono riservati solo
nel namespace globale, e si possono usare tranquillamente (almeno in
teoria) come membri di classe, parametri di funzione, variabili
locali, ...
        Mauro

         Mauro
Sbirish

 ma le macro non hanno scope :)
Le macro sono il MALE. :)))
E di solito sono tutte maiuscole... :)))
Ciao!
Azathot