Verständnisfrage, warum m=-1?

[tk80]

Aufgabenstellung:

Es gibt eine Welt mit vershiedenen Städten.
Jede Stadt hat 4 Tore. Von jedem Tor führt ein Weg (oder kein Weg) zu einer anderen Stadt.
Wege dürfen sich nicht kreuzen.

Mann muss alle Städte ausgeben, die direkt (dh ohne Umweg über andere Städte) miteinander verbunden sind.

Hauptmethode:

void direkterWeg(String St1, String St2) {
Weg w = direkt(St1, St2);
if (w!=null) {
zeigeAus("Direkter Weg: " + St1 + " "
+ TorName (TorIndex (wo(St1), w)) + ", "
+ w.Laenge + ", " + St2 + " "
+ TorName (TorIndex (wo(St2), w)) );
} else {
zeigeAus("Kein direkter Weg zwischen "
+ St1 + " und " + St2);
}
}

Hilfsmethode:

Weg direkt (String St1, String St2) {
Stadt s1 = wo(St1), s2 = wo(St2);
int tor=-1, laenge=0;
for(int i=0; i<4; i++) {
if (
(Nachbar(s1, i) == s2) && ((tor == -1)
|| (s1.Tor[i].Laenge < laenge)))
{
tor=i;
laenge = s1.Tor[i].Laenge;
}
}
if (tor>=0) {
return s1.Tor[tor];
} else {
return null;
}
}

warum wird tor mit -1 initialisiert? Was hat das für einen Zweck? Eigentlich kann doch tor gar nicht -1 werden??

Wann hat es Sinn int-Varibalen mit -1 zu initialisieren und was bedeutet das?

DANKE!

 

[SlaterB]

-1 heißt hier 'undefiniert',
es ist nicht sicher ob tor in der folgenden Schleife + if einen Wert bekommt,
am Ende will man aber mit tor arbeiten, also prüft man am Ende ob tor noch -1 ist,
wenn ja, dann wurde tor kein Wert zugewiesen, ansonsten schon

 

[hupfdule]

warum wird tor mit -1 initialisiert? Was hat das für einen Zweck? Eigentlich kann doch tor gar nicht -1 werden??

Eben genau deswegen. Sollte tor bis am Ende den Wert -1 behalten, ist es klar ersichtlich, dass da etwas nicht stimmt. -1 wird gerne für int-Werte verwendet, da diese ja nicht 'nullable' sind. Objekte würde man normalerweise mit null initialisieren. Da das bei int nicht möglich ist, weicht man halt gezwungenermaßen auf einen derartigen 'ungültigen' Wert aus.

 

[TRunKX]

Kannst auch int nullable kriegen. wenn du wirklich OOP betreibst dann machste doch eh

nicht int i = 0;

sondern:

private Integer i = null;

 

[Guest]

Kannst auch int nullable kriegen. wenn du wirklich OOP betreibst dann machste doch eh

nicht int i = 0;

sondern:

private Integer i = null;

Was hat die Verwendung von Integer mit wirklichem OOP zu tun?

Ich verwende doch nicht ein Integer-Objekt, wenn ich ganz einfach nur ne kleine Ganzzahl will, egal ob OOP oder nicht.

 

[tk80]

noch eine Frage:
(alle Städte sind in einer linearen Liste angeordnet)

 void Weg()
  {
  	Stadt s1 = Staedte; //Staedte = Kopf
  	Stadt s2;
  	
  	int h = 0;
  	int n = wegzaehler();
  	int [] a = new int[n]
  	
  	while (s1 != null)
  	{
  		s2 = s1.Nf;
  		while (s2!=null)
  		{...
.
.
.

verstehe ich das richtig, erstmal kuckt man, ob s1 leer ist, wenn nicht wird gekuckt, ob s1 einen Nachfolger hat und wenn ja, wird so zusagen s2 zu s1 (also Kopf) und die Restliste wird durchlaufen???

 

[SlaterB]

> wenn nicht wird gekuckt, ob s1 einen Nachfolger hat und wenn ja, wird so zusagen s2 zu s1 (also Kopf)

s2 wird nie zu s1, sondern zu s1.Nf

und dies passiert doch BEVOR 'gekuckt [wird], ob s1 einen Nachfolger hat'
denn erst wenn s2 gesetzt ist wird geprüft (while (s2!=null))

 

[tk80]

Hmm...verstehe ich nicht ganz...

also ich habe s1 (=Kopf)

dann habe ich s2 (noch weiss ich nicht, ob s2 null ist oder nicht)
s2 wird zum Nachfolger von s1

wenn s2 nicht null ist, wird weiter gemacht...

ist das jetzt richtig?

 

[SlaterB]

> dann habe ich s2 (noch weiss ich nicht, ob s2 null ist oder nicht)

genauer: an dieser Stelle (bevor s2 zum Nachfolger von s1 wird ) ist s2 gar nix und das weiß man auch und ist auch so gedacht

Rest richtig

 

[tk80]

Und warum ist das so gedacht?

 

[SlaterB]

...


s2 = s1.Nf;
würde nicht funktionieren wenn s1 null ist, also kann man das erst nach dem Test machen,

nun könnte man
Stadt s2= s1.Nf;
in einer Zeile schreiben, aber wenn man die Variable außen definieren möchte dann in zwei Schritten wie oben,
warum die Variable ganz am Anfang definiert wird kann ich auch nicht sagen,
Geschmackssache

 

[tk80]

Die Aufgabe war, alle Weglängen auszugeben und zwar aufsteigend soritert

void weglaengen()
    {
        int n = wegzaehler();
        int a[] = new int [n];
        int h = 0;
        
        Stadt s1 = Staedte;
        Stadt s2;
        
        while (s1!=null)
        {
            s2 = s1.Nf;
            
            while (s2!=null)
            {
                for (int i=0;i<4;i++)
                {
                    if (Nachbar(s1,i)==s2)           
                        a[h] = s1.Tor[i].Laenge;      
                        h++;                                  
                    }        
                }
                s2 = s2.Nf;    
            }
            s1 = s1.Nf;    
        }

Was ich nicht verstehe: warum wird s2=s2.Nf und s1=s1.Nf
Was bedeutet das?