einfach frage zu schleifen und so

Hallo.

Kann mir jemand sagen, was die folgenden Sachen bedeuten (was passiert da)?

cur=cur->next;

Text *cu=he, *ne; //he ist ein Pointer der auf etwas verweist- das hier verwirrt mich am meisten :eek:

und diese drei Schleifen:

kopf *kn;
if((pos--==1)&&(kn=new kopf(d, he)))
{
he=kn;
zaehler++;
return(1);
}

if(kn=new kopf(d, cur->next))  

if(!(kn->next))

Ich möchte eigentlich nur Wissen, was die einzelne Zuweisung oder Bedingung ist und so...

Danke

interpreter

Beginnerin schrieb:

Hallo.

Kann mir jemand sagen, was die folgenden Sachen bedeuten (was passiert da)?

cur=cur->next;  // cur wird auf den Nachfolger gesetzt

Text *cu=he, *ne; // in he steht ne Adresse (he zeigt auf was) Diese Adresse
                  // wird jetzt nach cu kopiert. Jetzt zeigen also he und cu 
                  // auf das selbe

und diese drei Schleifen: // Hier is keine einzige Schleife

kopf *kn;
if((pos--==1)&&(kn=new kopf(d, he)))   // Wenn pos 1 ist UND new ne 
                                       // Adresse ungleich 0 zurückgibt, dann ist die Bedingung wahr.
                  // Die 2. Bedingung ist glaube ich sinnlos, da new eine 
                  // eine Exception wirft, wenn kein Speicher allokiert werden kann. Unabhängig vom Ergebnis der Bedingung wird der Inhalt von pos um 1 erniedrigt. Anmerkung: Der 2. Ausdruck mit dem new wird nur ausgeführt, wenn pos =1 (wegen dem short circuit &&)
{
he=kn;            // he zeigt auf den gerade neu allokierten knoten
zaehler++;        // zaehler wird um 1 erhöht
return(1);        // Funktion verlassen und 1 an den Caller zurückgeben
}

if(kn=new kopf(d, cur->next))    // Siehe oben

if(!(kn->next))       // Diese Bedingung ist wahr, wenn next auf nichts (NULL) zeigt

Ich möchte eigentlich nur Wissen, was die einzelne Zuweisung oder Bedingung ist und so...

Danke

interpreter

Beginnerin schrieb:

Ich möchte eigentlich nur Wissen, was die einzelne Zuweisung oder Bedingung ist und so...

Text *cu=he, *ne; // in he steht ne Adresse (he zeigt auf was) Diese Adresse
// wird jetzt nach cu kopiert. Jetzt zeigen also he und cu
// auf das selbe

cu bekommt den inhalt von he...das is noch klar...aber warum wurde da ein komma und *ne noch hinzugefügt....was bewirgt das? cu kann doch nicht auf beides zeigen, oder?

interpreter

Beginnerin schrieb:

Text *cu=he, *ne; // in he steht ne Adresse (he zeigt auf was) Diese Adresse
// wird jetzt nach cu kopiert. Jetzt zeigen also he und cu
// auf das selbe

cu bekommt den inhalt von he...das is noch klar...aber warum wurde da ein komma und *ne noch hinzugefügt....was bewirgt das? cu kann doch nicht auf beides zeigen, oder?

Hier werden einfach in einer Zeile 2 Variablen auf einmal definiert. Das kannst du auch in 2 Zeilen schreiben, dann ist es vielleicht verständlicher:

Text *cu=he;  // Pointer auf Text definieren und mit dem Inhalt von he initialisieren
Text *ne;     // Noch  nen Pointer auf Text anlegen und nicht initialisieren (da steht jetzt irgend ein Schrott drinnen).

cu zeigt danach nur auf das, auf das auch he zeigt und nicht, wie du bereits richtig vermutet hast, auf beides.

aaah

alles klar....supi

ich dachte schon ich hätte mich verlesen

DANKEEEEE

hab noch mal ne kleine ergänzung zu den fragen *g*

was passiert hier?

cur->next=pos; // wird hier erst pos an next gegeben und dann cur auf next gesetzt?

last->next=cur->next; // what the heck? ^^

cur=anfg->next // wird hier anfg auf den wert von next gesetzt und dann an cur gegeben?

zeiger=zeiger2=new objekt (bla bli blubb) // erzeugen dann beide zeiger je ein obejekt auf dem heap, oder beide zusammen ein obejkt?

und:

wenn in einer funktion mehrere if-blöcke hintereinander stehen(nicht verschachtelt!), die jeweils nur mit 1 oder 0 returnen, läuft der die funktion dann so lange ab, bis irgendein if-block 0 liefert, oder läuft er die funktion so oder so komplett durch?

interpreter

Beginnerin schrieb:

hab noch mal ne kleine ergänzung zu den fragen *g*

was passiert hier?

cur->next=pos; // cur ist ein Zeiger, der auf irgend eine Struktur zeigt (cur->next ist das selbe wie (*cur).next und damit sprichst du den Inhalt von next der Struktur an, auf die cur zeigt. Es wird also die Variable next der Struktur, auf die cur zeigt mit dem Inhalt von pos gefüllt

last->next=cur->next; // next der Struktur, auf die last zeigt, wird mit next der struktur auf die cur zeigt gefüllt. Bildlich:

cur ----- zeigt auf ne Struktur ------>  { next = 0xAABBCCDD }
last ----- zeigt auf ne Struktur ------> { next = 0x00000000 }
und nach der Zuweisung sieht es so aus:
cur ----- zeigt auf ne Struktur ------>  { next = 0xAABBCCDD }
last ----- zeigt auf ne Struktur ------> { next = 0xAABBCCDD }

cur=anfg->next // Nein. Du musst dir die Bedeutung des ->operators klar machen. -> bedeutet: Dereferenziere und greife auf eine Variable innerhalb der Struktur/KLasse auf die ich zeige zu. Es wird also der INhalt von next der Struktur, auf die anfg zeigt nach cur kopiert

zeiger=zeiger2=new objekt (bla bli blubb) // erzeugen dann beide zeiger je ein obejekt auf dem heap, oder beide zusammen ein obejkt?

Nein. Es wird 1 Objekt auf dem Heap erzeugt und die Adresse des erzeugten Objekts wird dann zeiger und zeiger2 zugewiesen (beide zeigen auf das selbe Objekt). Ich hoffe, ich habe mich einigermaßen verständlich ausgedrückt =)

und:

wenn in einer funktion mehrere if-blöcke hintereinander stehen(nicht verschachtelt!), die jeweils nur mit 1 oder 0 returnen, läuft der die funktion dann so lange ab, bis irgendein if-block 0 liefert, oder läuft er die funktion so oder so komplett durch?

Wenn du lauter if() Anweisungen hintereinander hast, dann werden ALLE nacheinander geprüft. Wenn du willst, dass das prüfen der Bedingungen bei einer wahren Bedingung gestoppt werden soll, dann musst du else if()s benutzen.

also wird die funktion auf jedenfall komplett durchlaufen, egal was für ein return wert von den einzelnen ifs kommt?

danke nochmal

nman

Nein, beim return wird wieder zurückgesprungen aus der Funktion.

interpreter

Beginnerin schrieb:

also wird die funktion auf jedenfall komplett durchlaufen, egal was für ein return wert von den einzelnen ifs kommt?

danke nochmal

An einem Beispiel wird es dir sicherlich klarer:

#include <iostream>
using namespace std;

int main() { 
   // Fall1: Lauter ifs
   if(1)
      cout << "1" << endl;   // 1 wird ausgegeben, weil die Bedingung wahr ist
   if(2)
      cout << "2" << endl;   // Obwohl die Bedingung darüber bereits wahr war (*g), wird auch diese Bedingung getestet, da hier nur if steht. Da sie wahr ist, wird auch 2 ausgegeben
   if(0)                    // Auch diese Bedingung wird getestet, allerdings
      cout << "0" << endl;  // ... wird das nicht ausgegeben, da die Bed. falsch ist
   if(3)                    // Wird auch getestet
      cout << "3" << endl;

   // Fall2: if mit else ifs
   if(1)                       // Wird ausgewertet und da die Bed. wahr ist...
      cout << "a1" << endl;    // wird "a1" ausgegeben
   else if(2)                  // Alle nachfolgenden else ifs() werden garnicht
      cout << "a2" << endl;    // mehr überprüft, da das if() bereits wahr war
   else if(0)
      cout << "a3" << endl;

   cin.get();
   return 0;
}

Puh!

Dann kann ich ja jetzt beruhigt schlafen gehen

Vielen Dank, dass du dir soviel Zeit für mich genommen hast...und das auch noch so zügig!

Gute Nacht dann

interpreter

Beginnerin schrieb:

Puh!

Dann kann ich ja jetzt beruhigt schlafen gehen

Vielen Dank, dass du dir soviel Zeit für mich genommen hast...und das auch noch so zügig!

Gute Nacht dann

n8n8