06/01/2020, 00:53
int p = 0;
"dichiara e inizializza una variabile" p
: posso vedere p
esattamente come il numero 0
? O è più giusto pensare a essa come ad un contenitore per l'indirizzo di un oggetto 0
nello stack? (Non mi pare di ricordare di "un'indirizzo di una cosa nello stack", però...).public static void foo_1(Foo f) {
f = new Foo();
}
public static void foo_2(Foo f) {
f.fuckUp();
}
Foo
avente un metodo fuckUp
abbastanza autoesplicativo, ad esempio comeFoo f = new Foo();
foo_1(f);
// f è ancora lo stesso di prima
// ma...
foo_2(f);
// ...ora no >:S
*
e ->
di dereference; più il fatto che i riferimenti in stile C++ in Java non ci sono: il che rende "strano" il comportamento di cose passate by-value (unica "modalità di passaggio" di cui Java dispone, in ogni caso). Sbaglio? È per questo che certe persone inveiscono contro chi usa il termine "puntatore", riguardo a Java?swap
-test (non posso definire una funzione swap
che (pseudocodice)swap(a,b) {
tmp = a
a = b
b = tmp
}
a, b = 10,57
swap(a,b)
// a,b sono ora 57,10
void swap(Foo& a, Foo& b) {
Foo tmp = a;
a = b;
b = tmp;
}
06/01/2020, 07:33
ma che significa esattamente ciò? La riga di codice int p = 0; "dichiara e inizializza una variabile" p: posso vedere p esattamente come il numero 0?
O è più giusto pensare a essa come ad un contenitore per l'indirizzo di un oggetto 0 nello stack?
ci accorgiamo di alcune stranezze.
È per questo che certe persone inveiscono contro chi usa il termine "puntatore", riguardo a Java?
Il prof. non vuole sentir chiamare le variabili "variabili" (tantomeno "puntatori"), ma "riferimenti". [...] E in Python, cosa sono le variabili (o chi per loro)?
06/01/2020, 12:50
Ok. Mi è più chiaro.probid ha scritto:Il compilatore mantiene una tabella dei simboli
Le ho chiamate "stranezze" perché il comportamento dei metodiprobid ha scritto:Non ho capito perchè parli di stranezze, è il comportamento normale del passaggio per valore. Dovrebbe essere così anche in C++, se non usi i riferimenti.
foo_1
e foo_2
non è coerente con il fatto che Foo f = new Foo();
, in Java, è un puntatore (o qualcosa di molto molto simile). Considera quello che succederebbe in C++: quali tra questi metodi si comportano come l'analogo in Java?void foo_1(Foo* f) {
f = new Foo();
}
void foo_2a(Foo* f) {
f.fuckUp();
}
void foo_2b(Foo* f) {
f->fuckUp();
}
foo_1
e foo_2b
(mentre foo_2a
, che mi auguro non abbia senso nemmeno in C++, è scritto esattamente come se stessi digitando codice Java). Se i riferimenti di Java (o di Python, in base a quanto ho capito) fossero riferimenti veri, un chiamata a foo_1
avrebbe effetti collaterali (e invece non ne ha). Se i puntatori di Java fossero veri puntatori, non dovrebbe essere nemmeno possibile chiamare foo_2a
(perché, in genere, un puntatore non ha un metodo fuckUp()
.pop
). Mi confermi che il comportamento delle "variabili" in Python è esattamente lo stesso che in Java, ossia quello di "puntatori" senza aritmetica dove non c'è mai bisogno di dereference (dei *
e ->
C++-like)?08/01/2020, 17:30
Stavo cercando esattamente di capire meglio la discussione a quel link.Sergio ha scritto:Maggiori dettagli qui.
08/01/2020, 17:30
Stavo cercando esattamente di capire meglio la discussione a quel link.Sergio ha scritto:Maggiori dettagli qui.
Skuola.net News è una testata giornalistica iscritta al Registro degli Operatori della Comunicazione.
Registrazione: n° 20792 del 23/12/2010.
©2000—
Skuola Network s.r.l. Tutti i diritti riservati. — P.I. 10404470014.
Powered by phpBB © phpBB Group - Privacy policy - Cookie privacy
phpBB Mobile / SEO by Artodia.