Disclaimer: Dieser Thread wurde aus dem alten Forum importiert. Daher werden eventuell nicht alle Formatierungen richtig angezeigt. Der ursprüngliche Thread beginnt im zweiten Post dieses Threads.
2.4. negative - Problem Variable zu belegen
Ich hab ein komisches Problem mit der negative-Routine.
Zur Kontrolle lass ich mir schrittweise das komplette Zahlen-Array ausgeben,
damit sehe ich, dass innerhalb der negative-Routine schrittweise
das Invertieren, Überlaufbits löschen und 1 addieren (am Bsp. 1 negieren) funktioniert.
Aber in der main kommt das 1 addieren nicht an (und gibt folgerichtig Fehlermeldung).
Am Ende meiner negative-Routine habe ich
[color=blue]
binaerAusgeben(a); //das ist meine Kontrollausgabe auf der Konsole
int[] eins = {1, 0, 0, 0};
a = add(a, eins);
binaerAusgeben(a); [/color]
und bekomme erst die …1110 (Stand nach dem Invertieren u. Überlaufbits löschen)
und dann die richtige Zahl mit …1111 am Ende angezeigt.
D.h. hier funktioniert das 1 addieren offensichtlich.
(und die add-Routine ist auch sonst gut getestet und funktioniert)
ABER
wenn ich mir dazu nach dem Aufruf von negative(a) die Zahl in der main wieder anzeigen lasse,
[color=blue]negative(a);
binaerAusgeben(a);[/color]
wird …1110 angezeigt,
als ob die 1-Addition nie stattgefunden hätte.
ich steh auf’m Schlauch, wie kann das sein??
Ich muss irgendeinen dummen Hänger haben,
das hat wohl weniger mit dem eigentlichen Zahlen-Array-Problem der Aufgabe zu tun,
als vielmehr irgend ein dummer Grundfehler bei Wertzuweisungen.
Aber a = add(a, eins) setzt doch den Zeiger der Variable a auf das von add neu erstellte Summen-Objekt (Array),
das muss doch das Verlassen der negative-Routine und Rücksprung in die main “überleben”.
Kann mir jemand einen Schubser geben? 
Danke!
Wenn ich die abschließende Addition von 1 in der negative-Routine “per Hand” durchführe statt mit Aufruf
der add-Methode, dann geht alles.
Schaut aber nach sinnloser code-Duplizierung aus und erklärt noch nicht,
was eigentlich gehangen hat.
Die Zeiger auf die Arrays sind call-by-value. Dadurch gelangt das nie in die main.
Ah, Danke für den Hinweis!
Da darf ich wohl noch mal ein bischen nachlesen…
P.S. an die Manschaft von den Übungen:
die Übungs-Folien sind super!
ok, ich glaub, ich habs verstanden.
Falls es sonst noch jemandem hilft & zur Kontrolle, ob meine Überlegungen stimmen:
Beim Aufruf negative(a) werden NICHT die Werte des Arrays übergeben,
sondern eine Kopie der Referenz auf das übergebene Array (Stichwort flache Kopie).
äh, wir haben in Java zwar call-by-value, aber der hier kopierte Wert ist ja selbst eine Objekt-Referenz.
Sprachverwirrung, Seufz!
Da die Methode mit “negative(int a[])” implementiert war,
wird diese Referenz-Kopie dort intern auch mit a bezeichnet, aber dies ist eine lokale Variable,
die genausogut anders heißen könnte,
z.B. “negative(int kaffee[])” hätte in der Implementierung stehen können.
Da die Referenzkopie (noch) auf das selbe Array-Objekt zeigt,
kann ich durch kaffee[1] = 42 oder kaffee[2] = ~kaffee[2] den Inhalt des Original-Objektes (Arrays) ändern.
Aber wenn ich die Referenzkopie auf etwas anderes zeigen lasse,
z.B. kaffee = add(b, c)
zeigt mein a in der main immer noch unverändert auf “sein” Objekt und zeigt keine Veränderung.
Wenn ich also schon meine fertige add-Methode verwenden will (die ein neu erzeugtes Objekt zurückgibt),
dann muss ich eine Hilfsvariable verwenden, von der ich dann die Array-Einträge der Reihe nach in mein Original-Array (auf das meine Referenzvariable kaffee immer noch zeigt) reinkopiere:
etwa so:
int[] hilfskaffee = add(kaffee, {1, 0, 0, 0});
for (int j = 0; j < 4; j++){
kaffee[j] = hilfskaffee[j];
}
Jedenfalls hat es so bei mir endlich auch mit add geklappt, also scheine das so richtig dargestellt zu sein. hoffentlich…
System (Java Platform SE 7 )(java.lang.Object, int, java.lang.Object, int, int) 