[Java] Noob vraag: waarom while(true)?

[Zoijar]

H!GHGuY schreef op maandag 22 juli 2013 @ 12:33:
Net als een hond, lijkt een goeie compiler op z'n baasje
-Wall, -Wextra -pedantic, -Weffc++, -Werror

Dat ziet er goed uit in ieder geval -- kan niet oordelen over het baasje Vervelende vind ik alleen altijd die warnings als unused variable ed. Kan je er wel een unused macro omheenzetten, maar dat is ook een beetje vies... eigenlijk zou men daar wel C++11 attributes voor kunnen introduceren: void foo(int x [[std::unused]]) {} Als je hem dan toch gebruikt kan je compiler ook een warning: using unused variable uitspugen. Ik vind attributes hier ook wel geschikt voor omdat het echt meta-informatie voor je compiler is.

[ Voor 14% gewijzigd door Zoijar op 22-07-2013 13:57 ]

[Hatsieflatsie]

NMe schreef op vrijdag 19 juli 2013 @ 10:22:
[...]

Ten eerste is dit niet gerelateerd aan dit topic en ten tweede is dit prima te vinden op het internet.

Bestaan er trefwoorden daarvoor, waar ik kan zoeken waarom bijv Dog = d geen optie zou zijn?

[NMe]

Om te beginnen omdat de assignment-operator right-associative is (niet lullig bedoeld, maar dat is toch écht programmeren les 1) en het dus d = Dog zou moeten zijn in dat geval. Daarnaast omdat je op die manier d gelijk zou stellen aan de class Dog in plaats van hem te instantiëren in een object, wat weer behandeld wordt in je boek. Sowieso staat je vraag min of meer uitgelegd op pagina 54 van je boek. Lees het boek nou gewoon eens rustig door voor je vragen stelt. Jij moet helemaal nog niet op zoek naar trefwoorden, je hebt éérst de basis nodig.

[ Voor 5% gewijzigd door NMe op 22-07-2013 18:16 ]

[Daos]

(right-)associative is niet relevant hier. Dat zegt hoe haakjes geplaatst moeten worden. Neem bijvoorbeeld:
a + b + c. + is left-associative en wordt (a + b) + c;
a = b = c. = is right-associative en wordt a = (b = c).


In Java moet je je variabelen eerst declareren (term: 'variable declaration') en een type geven. Dit doe je zo:

Java:

Dog d;

Vervolgens ga je iets opslaan in d. Twee termen die je hiervoor zoekt zijn 'lvalue' en 'rvalue'. Links van = moet een lvalue staan zoals een variabele waarin je iets kan opslaan. In jouw voorbeeld is dit d. Rechts moet de waarde staan die je wilt opslaan. In jouw geval is dit een nieuwe Dog oftewel:

Java:

d = new Dog("Fikkie");

Declareren en een initiele waarde geven kan ook tegelijkertijd. De term hiervoor is 'variable definition'. Dit doe je zo:

Java:

Dog d = new Dog("Fikkie");

[Hatsieflatsie]

Bedankt voor jullie zéér behulpzame antwoorden, NMe en onvolprezen Daos. .

Nu kan ik weer verder zonder met prangende vragen te zitten, ook al lees ik het hele boek door.

[bwerg]

Daos schreef op maandag 22 juli 2013 @ 18:50:
Rechts moet de waarde staan die je wilt opslaan. In jouw geval is dit een nieuwe Dog oftewel:

Java:

d = new Dog("Fikkie");

Toevoeging: het kan ook een oude dog zijn, dus vandaar dat het type (Dog d) niet mag impliceren dat je ook een nieuw object aanmaakt (= new Dog()) met een constructor. Je mag ook doen:

Java:

Dog d1 = new Dog();
Dog d2 = d1;

Waarbij d2 wel een nieuwe variabele is, maar geen nieuw object.

Dus dan moge duidelijk zijn dat in de regel

Java:

Dog d = new Dog("Fikkie");

echt geen overbodige dingen staan.

Maar dat wordt allemaal wel duidelijk als je wat leest over references.

[ Voor 5% gewijzigd door bwerg op 22-07-2013 21:39 ]

[Zoijar]

Het 'new' keyword zou strict gezien niet nodig zijn, maar zo werkt Java nou eenmaal. In een nieuwe taal, met een slimmere compiler/parser zou je het anders kunnen doen.

Java heeft overigens geen references (ook al heten ze zo, "foutje" in de specificatie), alleen pointers (die pass-by-value worden doorgegeven) Maar ik zal het niet te ingewikkeld/verwarrend maken

[ Voor 7% gewijzigd door Zoijar op 22-07-2013 23:26 ]

[Woy]

Zoijar schreef op maandag 22 juli 2013 @ 23:25:
Het 'new' keyword zou strict gezien niet nodig zijn, maar zo werkt Java nou eenmaal. In een nieuwe taal, met een slimmere compiler/parser zou je het anders kunnen doen.

Het zou alleen wel wat ambiguïteit opleveren tussen een method Dog en de constructor van Dog. Maar verder zou dat prima mogelijk zijn. Dat is natuurlijk op te lossen met een syntax als C++, of door de typename er voor te zetten, maar dan vindt ik het new keyword niet zo storend, want het schept IMHO ook duidelijkheid over wat je doet.

Java heeft overigens geen references (ook al heten ze zo, "foutje" in de specificatie), alleen pointers (die pass-by-value worden doorgegeven) Maar ik zal het niet te ingewikkeld/verwarrend maken

Wat is jouw definitie van reference dan? Ik ben het er mee eens dat het meer op een pointer van C++ lijkt, maar zie niet waarom het geen reference kan heten. Die reference wordt natuurlijk wel by-value doorgegeven

[ Voor 10% gewijzigd door Woy op 23-07-2013 08:42 ]

[Herko_ter_Horst]

Zoijar schreef op maandag 22 juli 2013 @ 23:25:
Java heeft overigens geen references (ook al heten ze zo, "foutje" in de specificatie), alleen pointers (die pass-by-value worden doorgegeven) Maar ik zal het niet te ingewikkeld/verwarrend maken

Omdat je volgens mij iets zegt wat niet klopt, moet ik hier toch even op ingaan, want zonder verdere definitie van termen kom je hier niet mee weg

References in Java zijn een implementatie van het algemene begrip reference, maar het zijn beslist geen pointers.

De term 'reference' is echt geen foutje in de spec. References in Java zijn een laagje over pointers heen. Je hebt in Java niet rechtstreeks toegang tot de onderliggende pointer. M.a.w. Java kent geen pointers zoals C/C++ (bijv. pointer-arithmetic is niet mogelijk).

En ja, aangezien alles in Java by-value wordt doorgegeven, worden ook references by-value doorgegeven.

[Zoijar]

Omdat references een alias zijn voor hetzelfde object, en java pointers by-value doorgeeft.

Java:

void foo(Dog d) { // d is pass-by-value pointer; d is _local_
    d = new Dog("woef");
}

Dog a = new Dog("fikkie");
foo(a);
// a = "fikkie" hier

C++:

void foo(Dog& d) { // & = reference, is alias to caller's object, 'd' and 'a' are one and the same
    d = Dog("woef");
}

Dog a("fikkie");
foo(a);
// a = "woef" hier

Toen ik Java moest leren op de universiteit kon ik al redelijk programmeren in C++ en assembly, en is dit aspect van java nooit goed en duidelijk uitgelegd. Daarom heeft het een tijd geduurd voordat ik het echt begreep. Terwijl het eigenlijk heel simpel is. Ik wou dat iemand mij dit in de eerste week had verteld, in plaats van "java is pass-by-value, alleen objecten zijn references en strings zijn immutable" met wat handgewuif

Het zijn alleen references in de zin dat je er geen pointer arithmetic op kan doen; verder gedragen ze zich exact als pointers, inclusief een speciale null reference (C++ kent die ook niet; je kan geen alias hebben naar een object dat niet bestaat)

[ Voor 46% gewijzigd door Zoijar op 23-07-2013 09:29 ]

[Woy]

Dat is inderdaad de C++ definitie, maar dat maakt niet meteen dat het in Java verkeerd is. Ook in C#/.NET noemen ze het gewoon references, die standaard by-value doorgegeven worden. Daarom is het ook een MSDN: NullReferenceException Class (System)

Nou is dat wel iets geks in Java, want daar is het een NullPointerException

[ Voor 64% gewijzigd door Woy op 23-07-2013 09:21 ]

[Zoijar]

Woy schreef op dinsdag 23 juli 2013 @ 09:19:
Dat is inderdaad de C++ definitie, maar dat maakt niet meteen dat het in Java verkeerd is.

Reference als alias was op het moment dat Java bedacht werd zo'n beetje de interpretatie in elke taal (in het bijzonder C/C++ met een groot marktaandeel). Dan neem je niet hetzelfde woord over en geeft er een andere betekenis aan.Tenminste, blijkbaar wel, maar ik zie dat als 'foutje', al dan niet moedwillig. De rede is dat Java gemarket moest worden als veilig, en references waren veilig(er).

Woy schreef op dinsdag 23 juli 2013 @ 08:39:
Ik ben het er mee eens dat het meer op een pointer van C++ lijkt, maar zie niet waarom het geen reference kan heten.

Omdat ik de rem in een nieuw auto-ontwerp ook niet ineens koppeling noem

[ Voor 33% gewijzigd door Zoijar op 23-07-2013 09:32 ]

[Woy]

Maar het is in feite ook een alias van het object, alleen wordt die alias by-value doorgegeven waardoor er een nieuw alias naar hetzelfde object onstaat.

Een Java reference is ook niet hetzelfde als een C++ pointer, dus ook logisch dat ze het niet zo genoemd hebben. Dan hadden ze een compleet andere term moeten bedenken. IMHO is reference niet zo'n gekke term, ook al heeft het een andere betekenis dan in C++.

[Zoijar]

Het is gewoon erg verwarrend en ze hadden dat kunnen voorkomen door het pointers te noemen (wat het zijn: "The reference values (often just references) are pointers to these objects") met een expliciete note dat alle pointer arithmetic verboden/onmogelijk is. Dan had ik het persoonlijk vanaf dag 1 begrepen en niet pas jaren later

(het is imho echt puur gedaan omdat men altijd riep "oh, C/C++, moeilijk met pointers" en "pointer errors, pointers zijn foutgevoelig" Laten we het dan iets anders noemen om die associatie met moeilijk en onveilig te ontwijken in Java... ik ben geen grote fan van de taal zoals je ziet )

[ Voor 30% gewijzigd door Zoijar op 23-07-2013 09:58 ]

[Woy]

Tja, pointer en reference liggen gewoon erg dicht bij elkaar. Het is niet voor niks dat je voor pointers gebruik maakt van de reference en dereference operators

IMHO zijn zowel de definitie van pointer als reference uit C++ niet de juiste begrippen voor een Java reference. Ik geloof best dat de aversie van de C++ pointer de doorslag heeft gegeven om het references te noemen, maar ik zou zeker niet zo ver gaan om het fout te noemen.

Het feit dat je het pas jaren later doorhad is ook niet echt een goed argument IMHO, want het is niet alsof het niet duidelijk gespecificeerd is

[Herko_ter_Horst]

C/C++ pointers en references zijn twee implementaties van het algemene begrip "reference". Java references zijn een andere implementatie. Belangrijke verschillen met pointers zijn niet alleen het ontbreken van pointer arithmetic, maar ook de typing (en de bijbehorende bescherming tegen "foute" conversies).

En daarbij: de VM spec vereist dat references ondersteund worden, niet dat daarvoor pointers gebruikt worden.

[.oisyn]

Herko_ter_Horst schreef op dinsdag 23 juli 2013 @ 12:01:
maar ook de typing (en de bijbehorende bescherming tegen "foute" conversies).

Er zit zo goed als geen verschil tussen C++'s dynamic_cast en Java's cast. Behalve dat Java een C-style syntax gebruikt, wat in C++ resulteert in een static_cast danwel reinterpret_cast, al dan niet gecombineerd met een const_cast, en over het algemeen dus afgeraden wordt om te gebruiken juist omdat je hier zo snel mee de fout in kan gaan.

[ Voor 5% gewijzigd door .oisyn op 23-07-2013 12:10 ]

[Zoijar]

De verschillen in pointer gedrag zijn slechts wat restricties voor veiligheid. Het verschil met (C++) references of aliases is fundamenteel en functioneel. Het klassieke voorbeeld is dat het in Java zonder alias references onmogelijk is een directe swap functie te schrijven. References halen iets van buiten naar binnen je scope onder een andere naam.

Maar ok, het is maar een woord... Ik zal verder niet moeilijk doen Het belangrijkste punt is "java reference != C++ reference", en "Java reference ~= C++ pointer"

[Herko_ter_Horst]

.oisyn schreef op dinsdag 23 juli 2013 @ 12:10:
[...]

Er zit zo goed als geen verschil tussen C++'s dynamic_cast en Java's cast. Behalve dat Java een C-style syntax gebruikt, wat in C++ resulteert in een static_cast danwel reinterpret_cast, al dan niet gecombineerd met een const_cast, en over het algemeen dus afgeraden wordt om te gebruiken juist omdat je hier zo snel mee de fout in kan gaan.

Mijn C++ is te roestig om deze uitspraak op waarde te kunnen schatten, maar het voorbeeld dat ik via Googlen vond, is dat het met pointers mogelijk is om een int* te casten naar een char*, waarbij er dus herinterpretatie plaats vindt van wat er op dat geheugenadres is opgeslagen (wat in dit geval goed gaat omdat de geheugenstructuur toevallig gelijk is). Dit kan met Java references/casts niet.

Zoijar schreef op dinsdag 23 juli 2013 @ 13:10:
De verschillen in pointer gedrag zijn slechts wat restricties voor veiligheid. Het verschil met (C++) references of aliases is fundamenteel en functioneel. Het klassieke voorbeeld is dat het in Java zonder alias references onmogelijk is een directe swap functie te schrijven. References halen iets van buiten naar binnen je scope onder een andere naam.

M.i. is het verschil met pointers net zo functioneel en fundamenteel.

Het swap-voorbeeld heeft overigens niets te maken met of Java references nou meer op C++ references lijken of op pointers, maar met pass-by-reference vs. pass-by-value semantiek bij het doorgeven van variabelen. Als Java pass-by-reference semantiek zou implementeren, zou het prima mogelijk zijn om een directe swap-method te implementeren, ook voor de huidige references.

Dus wat mij betreft: "Java reference != C++ reference", en "Java reference != C++ pointer".

[ Voor 41% gewijzigd door Herko_ter_Horst op 23-07-2013 13:45 ]

[.oisyn]

Herko_ter_Horst schreef op dinsdag 23 juli 2013 @ 13:20:
[...]

Mijn C++ is te roestig om deze uitspraak op waarde te kunnen schatten, maar het voorbeeld dat ik via Googlen vond, is dat het met pointers mogelijk is om een int* te casten naar een char*, waarbij er dus herinterpretatie plaats vindt van wat er op dat geheugenadres is opgeslagen (wat in dit geval goed gaat omdat de geheugenstructuur toevallig gelijk is).

Klopt, als je dat wilt dan kán dat ja. Maar dat maakt een cast in C++ niet meteen onveilig - alleen reinterpret_cast is onveilig (en static_cast tot op zekere hoogte omdat je kunt downcasten naar een verkeerde klasse - een Dier* naar een Hond* bijvoorbeeld terwijl het eigenlijk een Kat is), maar ik zei niet voor niets dat het vergelijkbaar was met dynamic_cast waar gewoon zowel compiletime als runtime type checking op plaatsvindt.

Als je netjes gebruik maakt van de juiste cast methodes zul je nooit per ongeluk een foute cast doen.

[ Voor 5% gewijzigd door .oisyn op 23-07-2013 14:40 ]