Newsgroup: it.comp.java
Titolo: Ma i parametri non vengono passati per riferimento ?

Scusate il disturbo, ma un problema inatteso sta sconvolgendo quello che
credevo di sapere.
Non sono un programmatore Java di consumata esperienza, e forse è proprio la
mia scarsa esperienza la causa di questa difficoltà
Dai ricordi di quello che ho studiato (anche in tempi recenti) mi pare di
aver capito che in Java tutti i parametri vengono passati per riferimento.
Direi che questo significa che quando viene chiamato un metodo a cui viene
passato un parametro, in realtà quello che viene passato è un riferimento
alla variabile che viene passata come parametro.
Quindi se questa variabile viene modificata all'interno del metodo
richiamato, quando il metodo termina, mi dovrei ritorvare la variabile che
avevo passato al metodo modificata.
Però questa, che io consideravo una certezza, è stata smontata
clamorosamente dal seguente programma che produce il risultato riportato di
seguito al programma
Il sorgente incriminato è il seguente:
class ParaRif
{
  public static void main(String[] args)
  {
    ParaRif rif = new ParaRif();
    String msg = "Proviamo";
    rif.metodo(msg);
    System.out.println(msg);
  }
  public void metodo(String msg)
  {
    msg = "Speriamo";
    System.out.println(msg);
  }
}
Il risultato che ne derivia è
--------------------------------------------------------
Microsoft(R) Windows 98
   (C)Copyright Microsoft Corp 1981-1998.
C:\JBuilder2\java\bin\myclasses\Test>java ParaRif
Speriamo
Proviamo
C:\JBuilder2\java\bin\myclasses\Test>
---------------------------------------------------------
mentre, secondo le mie attese il risultato avrebbe dovuto essere:
--------------------------------------------------------
Microsoft(R) Windows 98
   (C)Copyright Microsoft Corp 1981-1998.
C:\JBuilder2\java\bin\myclasses\Test>java ParaRif
Proviamo
Proviamo
C:\JBuilder2\java\bin\myclasses\Test>
---------------------------------------------------------

 Proviamo
Correttissimo!!!
All'interno del tuo metodo metodo() hai semplicemente modificato
il VALORE del reference assegnandovi un NUOVO oggetto di tipo
String inizializzato al valore "Speriamo".
Siccome il reference e' passato al metodo PER VALORE, il chiamante
manterra' la propria copia del reference che puntera' ancora alla
stringa "Proviamo".
Nessun buco della JVM!!! ;)
Ciao
Roberto
-- 
+-------------------+
| Bagnoli Roberto   |
| Nouvelle srl      |
| MODENA (ITALY)    |
| 
rbag...@orion.it
 |
+-------------------+

 riferimento. 
No, sono passati sempre per valore, come in C.
Se pero' il tipo del parametro e' nonprimitivo, quello che passi *e'* un 
riferimento - un puntatore su cui pero' non puoi fare aritmetica.
-- 
Life's something u don't get out alive..
ObjectZone - 
http://space.tin.it/computer/csadun


La mia convinzione era dovuta al fatto che evidentemente i miei ricordi si
confondevano con qualche altro linguaggio, ma anche dal fatto che non mi è
mai capitato di vedere un esempio dove i parametri vengono passati per
riferimento, come invece mi è capitato di vedere in C++ (che un linguaggio
con il quale ho invece lavorato più a lungo).
In sostanza, saresti in grado di farmi un esempio della sintassi che avrei
dovuto usare per ottenere il risultato che volevo ?
Grazie
Ciao
Riccardo Suprani

 dovuto usare per ottenere il risultato che volevo ?
In Java, gli oggetti di tipo String sono "immutable", quindi non
e' possibile modificare una stringa una volta che e' stata
istanziata.
Se vuoi passare ad un metodo una stringa modificabile, puoi utilizzare 
la classe java.lang.StringBuffer
Saluti



Il risultato è giusto perchè tu chiami il metodo metodo(string msg).
Quando tu fai msg="Speriamo" quello che vai a modificare è la variabile
locale che vive dentro il metodo e nulla ha a che vedere con quella relativa
alla classe.
Successivamente all'uscita del metodo tu scrivi la variabile "globale" che
non è stata modificata.
Se avessi voluto cambiare la variabile relativa alla classe dentro il metodo
avresti dovuto scrivere:
this.msg="Speriamo";
Così facendo avresti in uscita due volte:
Speriamo
Speriamo.
.

Scusate ma mi sfugge qualcosa.............
Il passaggio degli oggetti avviene per riferimento (questo vale anche per
cose tipo assegnamento es :
Object b = new Object();
Object a = b;
se distruggo B perdo anche A) mentre per quello che riguarda i tipi di dati
elementari, questi vengono passati giustamente come dite voi per valore.
Il caso delle String è un caso a parte a mio avviso, perchè è stato
considerato giustamente un tipo di dato elementare (come in pascal) essendo
esplicitamente un oggetto con tanto di metodi (in realtà sappiamo tutti che
una stringa non è un dato elementare perché è effettivamente costituita da
caratteri).
In questo caso a mio parere ma potrei sbagliare alla grande, la SUN ha
applicato quella bella cosa che il C++ permette e cioé la possibilità di
assegnare metodi di una classe a operatori (come : =, *, /, +, etc.).
Già mi capitò di affrontare questo discorso con mio amico, che sosteneva che
passando un oggetto ad una metodo questo venisse duplicato ottnendo due
oggetti.
Io sostengo che facendo così si hanno due riferimenti allo stesso gruppo di
informazioni, niente di più che un puntatore.
Dimostrazione : abbiamo creato un oggetto che di per se conteneva dati per
qualcosa di calcolato pari a 30K più il peso dell'oggetto (conteneva degli
array e diversi Long), dopo di che abbiamo creato un array di 100.000
elementi di quel tipo, solo che invece di fare pippo[i] = onj.clone();
abbiamo fatto semplicemente pippo[i] = obj;
Risultato un array di istanze che occupa il peso di una istanza per 100.000
invece che 100.000 * 30K
Siete d'accordo con me?
Se vi ascolto molto volentieri, perché almeno approfondisco l'argomento.

 .
Ma non diciamo fesserie!!!
Lo statement this.msg, collocato all'interno del metodo metodo()
causerebbe semplicemente un errore di compilazione, perche' 
la classe ParaRif NON possiede un attributo di tipo String avente
nome msg!
Quella che tu chiami variabile globale (nozione senza senso nel
contesto del linguaggio Java) non e' affatto globale: e' un reference 
LOCALE al metodo (statico) main(), quindi non e' in alcun modo 
accessibile in modo diretto dal corpo del metodo (d'istanza) metodo()


Mi sono rivolto ad un mio carissimo amico, il quale mi ha dato una risposta
che considero come l'oro colato (in quanto so di certo che è un grosso
esperto di Java).
La sua risposta è stata la seguente:
- I parametri in Java vengono passati per riferimento e non per valore.
- Ogni "alterazione" di un oggetto String produce un NUOVO oggetto String
(l'han fatto apposta, i bastardi!!!).
- Traducendo l'esempio in C++ si ottiene il seguente codice
   metodo(char *msg2)
  {
     msg2= new String("Cacchio");
  }
  mentre quello che io voglio è
  metodo(char *msg2)
 {
    strcpy(msg2, "Cacchio");
 }
Infine suggerisce di risolvere il problema in questo modo
public class ProvaStringa
{
  public static void main(String[] args)
  {
    ProvaStringa rif = new ProvaStringa();
    A a= new A();
    a.x="Proviamo";
    System.out.println("Prima della chiamata i="+a.x);
    rif.metodoIntero(a);
    System.out.println("Dopo la chiamata i="+a.x);
  }
  public void metodoIntero(A a)
  {
    a.x= "Cacchio";
  }
}
public class A
{
   public int x;
}
Spero di essere stato utile alla causa di molti
Riccardo
P.S. Un ringraziamento al mio amico che non nomino per motivi di privacy

 Se vi ascolto molto volentieri, perché almeno approfondisco l'argomento.
-- 


 P.S. Un ringraziamento al mio amico che non nomino per motivi di privacy
E' meglio cosi' (per lui) ;)
Saluti
Roberto


Faccio una piccola correzione al sorgente che ho riportato nel messaggio
precedente
Il codice riportato qui di seguito è stato da me provato
public class ProvaStringa
{
  public static void main(String[] args)
  {
    ProvaStringa rif = new ProvaStringa();
    A a= new A();
    a.x="Proviamo";
    System.out.println("Prima della chiamata i="+a.x);
    rif.metodoIntero(a);
    System.out.println("Dopo la chiamata i="+a.x);
  }
  public void metodoIntero(A a)
  {
    a.x= "Cacchio";
    System.out.println("Durante la chiamata i="+a.x);
  }
}
class A
{
   public String x;
}
Il risultato che si ottiene è il seguente:
Prima della chiamata i=Proviamo
Durante la chiamata i=Cacchio
Dopo la chiamata i=Cacchio
Questo spiega chiaramente la teoria di questo mio amico di cui dicevo nel
messaggio precedente, e cioè che i parametri in Java sono passati per
riferimento (altrimenti avrei bisogno dei costruttori di copia come si usa
fare in C++, ma in Java i costruttori di copia non ci sono), ma la classe
String ha un comportamento anomalo rispetto alle altre classi, perchè ogni
sua variazione crea una nuova istanza che chiaramente avrà un riferimento
diverso dall'istanza precedente la modifica
Sono aperto al dibattito. Se qualcuno ha qualcosa da aggiungere ben venga
Riccardo

 diverso dall'istanza precedente la modifica
Questa l'hai compresa correttamente ;)
Saluti
Roberto
PS. Lo prometto: non intervengo piu' in questo thread ;)


 VENGONO PASSATI PER VALORE! (scusate se urlo)
E diversamente come potrebbero essere passati...in spirito??
Mi sembra una pignoleria da "sesso degli angeli..."
Arrivederci,
Seppo
-- 
Posted via Mailgate.ORG Server - 
http://www.Mailgate.ORG

 PS. Lo prometto: non intervengo piu' in questo thread ;)
speriamo non ce ne sia bisogno... comunque, se l'informazione puo'
aiutare nel processo decisionale (non che sia opinabile, ma non si sa
mai), questa versione e' quella che insegnamo in Sun.
uL


 Mi sembra una pignoleria da "sesso degli angeli..."
Non direi, in quanto e' proprio l'incomprensione di questa
sottile (ma determinante!) differenza la causa dei numerosi 
post su questo argomento (anche in passato).
Saluti
Roberto


 Seppo
"Reference" Java e passaggio per "reference" sono due accezioni diverse
del termine... la confusione IMHO si genera qui.
Comunque, per esempio, molte VM utilizzano reference a reference... come
ci mettiamo?
uL 


 si altera ;)) 
Grazie, ne avevo bisogno! ;)
Saluti
Roberto


 E' questa la distinzione fondamentale che va compresa fino in fondo.
Scusa ma il reference come dovrebbe essere passato se no?
Capisco il motivo per il quale batti i piedi.
Facciamo un esempio se in C/C++/Assembly dichiaro un puntatore ad una zona
di memoria allocata, potrei decidere di passare ad un altro puntatore due
cose :
1 - l'indirizzo della zona di memoria puntata, ottenendo così un riferimento
diretto (passaggio per valore, quello che dici tu).
2 - l'indirizzo della variabile puntatore, ottenedo una lista concatenata,
decisamente più ingarbugliata anche se potente. Quindi non un riferimento
diretto alla zona di memoria, ma un riferimento al puntatore che la punta.
In effetti hai ragione a specificare questo  anche se secondo me c'era da
spendere due parole in più sul fatto che la classe String pur essendo un
oggetto sfugge a queste regole perchè essendo stata considerata un tipo
elementare, crea sempre nuove istanze.
In effetti la possibilità di sfruttare l'overloading degli operatori (così
come fa la classe String (in maniera nascosta a mio avviso)) sarebbe stata
comoda.
Un parere sull'argomento sarebbe gradito.
Ciao e buona giornata a tutti.

 uL
Interessante...
A questo punto, come diceva quello, la domanda sorge spontanea:
1 - Potresti dirmi la differenza tra i due concetti?
2 - Se le VM fanno un pň come piů gli piace a seconda di quale adotti, 
    come si comporta il povero sviluppatore che vorrebbe un unico
modello
    di riferimento.
3 - Il secondo reference come viene passato al primo? No, scherzo! 
    Se no la finiamo a citare l'argomento ontologico (?) di S.
Anselmo...
PS: perň una risposta alle prime due mi piacerebbe sul serio.
Ri-arrivederci.
Seppo


 elementare, crea sempre nuove istanze.
Ripeto: la classe String NON sfugge affatto alle regole di passaggio dei
parametri, ma si comporta cosi' semplicemente perche' e' un "immutable",
come lo sono anche, per fare altri esempi, le istanze delle classi
wrapper 
dei tipi primitivi (Integer, Long, ecc.) e della classe
java.math.BigDecimal.
Per definizione, non si puo' alterare lo stato di una istanza
"immutable"
(lo dice la parola stessa ;).
Quindi, se un metodo riceve come parametro un reference ad una 
istanza "immutable" accade che:
- il reference non lo puo' modificare (dal punto di vista
  del chiamante) perche' gli viene passato per valore;
- lo stato dell'istanza "puntata" dal reference non puo'
  essere alterato perche' si tratta di un "immutable";
ne consegue che una qualsiasi operazione effettuata su 
quel reference NON si riflette ne' sul reference ne' sul 
corrispondente oggetto posseduti dal chiamante.
Cosi' e' piu' chiaro? 
(Ugo, aiuto!!! ;)
Saluti
Roberto


> Ma non diciamo fesserie!!!
si va bene ho letto male e di fretta.
Comunque rilassati.

Sinceramente: non so piu' come spiegarlo! ;)
[CUT]
Prova con le parole di qualcun altro ;-)
Leggere il già citato "Thinking In Java 2nd Ed." a pag 101 e, 
soprattutto, l'appendice A.
Se poi si vuole "esagereare" ci sono le specifiche del linguaggio (da 
pag 40 in poi in quelle che ho sotto mano: langspec-2.0.pdf)...
HTH
-- 
Ciao
	Fabrizio C.

 elementare, crea sempre nuove istanze.
Non e' un tipo elementare, solo una classe con la particolarita' 
dell'operator overloading per +.
Il pattern "Immutable" (usato anche nelle classi Wrapper,ad esempio, 
come gia' detto da Roberto) invece e' una tecnica nota per evitare di 
gestire aliasing, e puo' essere applicato ove ce ne sia bisogno: ossia 
puoi utilizzarlo per le tue classi...
ciao
uL

Premetto che le mie convinzioni in merito sono queste (e la letteratura
in merito mi sostiene, nn sara' certo java a cambiare la terminologia
tecnica):
il passaggio per riferimento :
        pusha nello stack il riferimento alla locazione di memoria del
        parametro passato, che e' modificabile dall'istanza invocata.
il passaggio per valore :
        istanzia sullo stack della classe invocata una nuova struttura
        dati del tipo del parametro, copiandoci uno per uno i valori.
Ora in java se io faccio una cosa del genere :
class Service{
    Param1 P1;
    Param2 P2;
    public Service( Param1 P1,Param2 P2){
        this.P1=P1;
        this.P2=P2;
    }
E invoco Service dall'esterno, noto che le modifiche fatte su P1 e P2
sono rilevabili anche nel contesto del chiamante.
Ergo :
le operazioni tipo this.P1=P1; this.P2=P2; non fanno altro che copiare
il riferimento al parametro nel riferimento della variabile di Service ;
il che vuol dire che non e' stata effettuata nessuna copia e il
riferimento e' stato trasmesso all'istanza chiamata.
Quindi, a giudicare dai risultati che si ottengono, in java il passaggio
di parametri avviene per riferimento, con la conseguenza del side-effect
e senza riallocazione di istanze.
Livio Viggiano

a ugo te stanno a ritornà stì =20  :)
Ciao

 e senza riallocazione di istanze.
Ci rinuncio...
-- 
+---------------------------+
| Roberto Bagnoli           |
| 
robe...@comune.modena.it
 |
+---------------------------+

 - I parametri in Java vengono passati per riferimento e non per valore.
ROFTL il tuo amico none' un grosso esperto java, o perlomeno non ha ben 
chiara la terminologia tecnica.


 Mi sembra una pignoleria da "sesso degli angeli..."
No, sono semplicemente nozioni di base.


Grazie a te e a Roberto per l'eccellente spiegazione sul tema.
Ciao

 
Allora, in Java il passaggio di parametri di tipo non scalare e' 
semanticamente molto simile al passaggio per riferimento, poiche' i 
parametri ti tipo non scalare *sono* acceduti solo tramite riferimento e 
non in altri modi (a la C++)
uL

 
Pure io... :) Fra l'altro ognuno e' libero di pensare quello che vuole 
(basta che 'sta leggenda metropolitana del passaggio per riferimento non 
si diffonda troppo...)
uL

 
e' vero, ho reinstallato Mozilla (il nuovo 0.9.8). Ora peo' dovrebbe 
essere tutto OK.
Chi sa a cosa servirebbe il 'quoted printable' MIME encoding per i 
caratteri 8 bit? (che dovrebbe essere il responsabile degli =20)
grazie!
uL

        parametro passato, che e' modificabile dall'istanza invocata.
Primo, un minimo di definizioni: 
1) algebraicamente puoi vedere lo stack frame di un metodo come un set 
ordinato di entry riferibili via nomi - coppie <n,v> (nome/valore).
Il concetto di "nome" come lo uso qui e' quello proprio di semantica 
denotazionale o calcolo dei predicati. Una brevissima panoramica la trovi a 
http://space.tin.it/computer/csadun/articoli/sem.html
; per un'introduzione 
piu' approfondita, con qualche accenno alla teoria dei dominii, dai 
un'occhiata a [Gordon, M.J. The denotational description of programming 
languages : an introduction, Springer Verlag, 1989] 
2) "passare un parametro" da un metodo M1 ad un metodo M2 consiste nel 
creare, nello stack frame di M2, una nuova coppia (usiamo M2:<n2, v2>) in 
certe relazioni con una corrispondente coppia nello stack frame di M1 
(usiamo M1:<n1, v1>). 
3) Quali siano esattamente queste relazioni dipende appunto dal tipo di 
passaggio.
4) Esiste una funzione m2=COPY(m1) che crea una copia di una zona di 
memoria. 
5) Esiste una funzione p=OPAQUE_POINTER(v) che crea un puntatore ad un 
valore v.
Ora, nel passaggio "per valore", la semantica del passaggio di M1:<n1,v1>, 
dove n1 e' il nome dell'i-esimo parametro nella chiamata, e' creare nello 
stack frame di M2 una coppia M2:<n2, COPY(v1)>, dove n2 e' il nome nella 
lista di actual parameter (names) di M2 in posizione i.
Nel passaggio "per riferimento", la semantica del passaggio di M1<n1,v1>, 
dove n1 e' il nome dell'i-esimo parametro nella chiamata, e' creare nello 
stack frame di M2 una coppia M2:<n2, OPAQUE_POINTER(v1)>, dove n2 e' il 
nome nella lista di actual parameter (names) di M2 in posizione i.
In Java, il passaggio e' sempre per valore perche' la semantica e' sempre 
la prima.
Per variabili di tipo primitivo, le coppie sono nella forma M1:<n1, v1>, 
dove v1 e' uno dei valori definiti dal tipo in questione (guardati la 
teoria dei tipi se questo non e' chiaro).
Per variabili di tipo nonprimitivo, in Java, le coppie sono nella forma 
M1:<n1, p1>, dove p1 e' *il valore* OPAQUE_POINTER(o1), e o1 e' un valore 
sullo heap (*non* nello stack frame). 
Questo perche' i *tipi* nonprimitivi in Java sono (del tutto 
indipendentemente dall'essere passati come parametri o no) coppie 
nome/valore in cui il valore e' nel dominio di OPAQUE_POINTER.
In altri termini, un puntatore ad un valore sullo heap ("l'oggetto"), su 
cui pero' non si puo' fare aritmetica - tecnicamente chiamato 
"riferimento". Il che non ha nulla a che vedere con il "passaggio per 
riferimento", se non il fatto che entrambi implicano l'operazione 
OPAQUE_POINTER.
Per tipi nonprimitivi quindi, sostituendo, passare M1:<n1, p1> significa 
creare M2:<n2, COPY(p1)>, ovvero M2:<n2, COPY(OPAQUE_POINTER(o1))>.
Il passaggio resta per valore, ma quello che viene copiato e' un 
riferimento. Ovvero, per variabili di tipo non primitivo, l'effetto finale 
e' di copiare sullo stack frame di M2 un puntatore opaco (riferimento) al 
valore sullo heap ("l'oggetto").
Cio' non implica affatto che il passaggio diventi "per riferimento", dato 
che la semantica di quest'ultimo e' ben diversa (ad esempio, quella fornita 
dall'operatore '&' in C++ quando usato in una dichiarazione di actual 
parameter (names); o dal modificatore VAR in pascal, stesso contesto), e in 
Java, come in C, questo tipo di passaggio di parametri non e' disponibile.


valore sullo heap ("l'oggetto").
Quindi 'in soldoni', il passaggio di un parametro di tipo 'non scalare' o 'non
primitivo' avviene per riferimento.
Apprezzo molto la chiarezza con cui hai dimostrato che, 'formalmente' il
passaggio avviene per valore (poiche' il 'valore' di un tipo non scalare
coincide con il suo puntatore) e capisco finalmente quale fosse
l'incomprensione tra le due opposte interpretazioni.
Continuo a non modificare la mia impostazione mentale, poiche' in un passaggio
per valore, dove il valore e' rappresentato dal riferimento, quello che
effettivamente si passa e' il riferimento.
Se pero' qualcuno dovesse chiedermi 'in che modo vengono passati i parametri in
java' da ora in poi rispondero' : PER VALORE ! (con il risultato che se il mio
interlocutore e' uno studente di media preparazione, egli andra' a modificare i
valori convinto di non provocare side-effect)
Ciao,
Livio Viggiano

 valori convinto di non provocare side-effect)
No, neanche questo e' vero. In Sun insegnamo la versione corretta e non 
quella "approssimata", e nessuno ha problemi.
Comunque, tanto per chiarirci un po', nessuno ha la conoscenza totale di 
un argomento complesso come Java (neanche Gosling, per intenderci), e 
tutti ci si affanna per approssimare sempre di piu' quello che si sa a 
tendere verso una utopistica "perfezione". Detto questo, spesso sarebbe 
piu' onesto e proficuo per *tutti* accettare di aver imparato qualcosa 
di nuovo senza continuare ad arroccarsi in posizioni indifendibili e non 
opinabili, tipo la precisione dei double o il passaggio dei parametri 
per valore.
my 0.02 euros
ciao
uL

 provocare side-effect) 
Oppure farai come provo a far io, semplificando senza pero' diventare 
approssimativi, e lui fara' la cosa giusta in ogni situazione. 
Il trucco per passare dalla media preparazione a quella buona e' capire 
come stanno effettivamente le cose. :-)


Ciao
Anche io le prime volte che ho programmato in Java ho fatto un po' di
confusione su questo argomento, dato che mi era stato detto che i
parametri
venevano passati per riferimento, e io conoscendo precedentemente il
C++, avevo
equivocato.
Vorrei fare un piccolo esempio sulla distinzione tra passaggio per
valore
di un reference (o puntatore in C++) a un oggetto e passaggio per
riferimento di un oggetto.
Mi rivolgo in particolare a chi ha una conoscenza base del C++.
NOTA: l'esempio che segue e' solo a scopo chiarificativo, e non vuole
rappresentare
una effettiva traduzione di funzioni Java in C++
Si osservi il seguente esempio. 
#include<iostream>
using namespace std;
void puntatore_by_val(int* x)
{
	x=new int(7);
	cout << "interno funzione: *x=" << *x <<endl;
}
void intero_by_ref(int& x)
{
	x=7;
	cout << "interno funzione: x=" << x <<endl;
}
int main()
{
	int* i = new int(5);  //*i = 5;  *x non definito
 
	puntatore_by_val(i);  // *i = 5;  *x = 7
 
	intero_by_ref(*i);  // *i = 7;  *x = 7
	return 0;
}
Quando chiamo puntatore_by_val(i) viene eseguita una copia del
puntatore (x=i); se poi nella funzione scrivo
"x=altro" semplicemente avro' che x non punta piu' all'oggetto puntato
da i, ma questo non viene modificato.
Potrei modificare (*i) solo dereferenziando x, ossia scrivendo *x=7.
Invece chiamando intero_by_ref(*i) parametro x e' semplicemente un
altro nome dell'intero puntato da i
(e non un alias del puntatore). Di conseguenza ogni operazione su x e'
eseguita anche sull'oggetto puntato.
Facendo un discorso puramente per analogia, direi che il passaggio di
parametri in Java "si comporta" in modo
piu' simile al "puntatore_by_val" che all'"intero_by_ref".
---
Riccardo

 > Se vi ascolto molto volentieri, perché almeno approfondisco l'argomento.
