Newsgroup: it.comp.lang.c++
Titolo: Efficenza return

Ciao a tutti
	ho la seguente curiosita':
Supponiamo una classe si fatta:
	class Pippo {
		int pippo_dat;
		...
	      public:
		int give_pippo() { return(pippo_dat); }
		...
	}
che ho scelto come esempio di un caso abbastanza comune, cioe' una
classe con un dato privato
accessibile all'esterno solo in lettura mediante una f. menbro apposita.
Quant'e' la differenza di efficenza tra l'accedere direttamente al dato
pippo_dat (es. dichiarando una classe friend di Pippo) e usare la
funzione menbro?
Oppure e' piu' chiaro rispondere alla seguente domanda:
Se give_pippo() viene effettivamente compilata inline (come probabile)
come viene compilata l'istruzione return(pippo_dat)? Di solito, mi
sembra, quando una funzione ritorna un valore questo viene copiato in un
apposito campo sullo stack allocato al momento della chiamata, quindi,
prima di deallocarlo, copiato in una var. da un eventuale assegnamento
(cioe' per es. tmp = pippo_obj.give_pippo();).
Scusate l'eventuale confusione, saro' grato a chiunque rispondera'.
Ciao
	Alessandro Strazzari

 come viene compilata l'istruzione return(pippo_dat)?
Come l'hai scritta, give_pippo viene compilata effettivamente in-line,
quindi e' effettivamente come accedere a pippo direttamente. Non c'e'
differenza di prestazioni.
Ciao!
-- 
 Daniele
------------------------ Fuck The Monopoly ! -----------------------
             ______                           ____                  
            /_  __/                          / __/                  
             / /__     __  __  __           / /_                    
            / //_  /  /_  /   / / /\/\     /_  / /  / \/ \/     
           / //__ /_ /__ /__ /_/ /   /    __/ / /__/  /\ /\       
          /_/ Italia                     /___/                      
 
  -> 264 <- days and telecom's monopoly will be fucked forever !    
 
--------------------------------------------------------------------
 Daniele Orlandi - Utility Line Italia - 
http://www.xt.net
 
 Via Mezzera 29/A - 20030 Seveso (MI) - Italy - FAX: 
++39(362)540153
--------------------------------------------------------------------

 (cioe' per es. tmp = pippo_obj.give_pippo();).
Analizziamo le cose con ordine:
Se parliamo di un compilatore ansi come ad esempio quelli che comunemente
trovi per personal computer o sistemi unix mini, allora la regola è la
seguente:
Se il valore ritornato dalla funzione è un tipo di dato fondamentale (o
base), allora viene restituito dalla funzione al chiamante semplicemente
appoggiandolo sui registri di CPU (su processori Intel utilizzando i
registri AX,DX,SI,DI o EAX,EDX,ESI,EDI se 32bit.
Nel caso di funzione che ritorna un tipo di dato derivato come ad esempio
una classe o una struttura (per copia intendo e non per puntatore o
riferimento), allora in questo caso viene utilizzato spazio dello stack.
Quindi un po' di considerazioni sono:
1) se ritorni un dato fondamentale (int, float, double, ecc) e la funzione
è inline, ottieni un grosso risparmio di fatiche.
2) comunque le funzioni inline fanno risparmiare cicli di CPU nel
ripristinare lo stato dello stack del chiamante.
3) se devi invece ritornare un dato più complesso, allora ti consiglio
altre tecniche, tipo passaggio di un'area per riferimento come parametro
alla chiamata o al limite ritornare un puntatore o un reference ad una
struttura statica alla funzione.
Se puoi evita sempre di ritornare dati derivati o comunque di una certa
complessità utilizzando il valore di ritorno di una funzione.
Tutto questo, vero anche per il 'C', aumenta di importanza se applicato al
'C++' in quanto entrano in gioco anche le funzioni di costruzione e
distruzione degli oggetti intermedi, cosa che potrebbe far perdere molto
tempo al programma.
Scusa se sono stato prolisso, ma questa è solo una breve 'infarinatura' su
un argomento troppo spesso sottovalutato da chi sviluppa codice (come dire:
la solita punta del solito iceberg).
-- 
~~~~~~~~ Stefano Mazzotti ~~~~~~~~~
    from Faenza, Ravenna, Italy
   e-mail: 
smaz...@racine.ra.it
~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~