Ich bin neu in C++ und dabei auf folgenden Code gestossen:

struct node {
    int wert;
    node *next;
};

void TeileGeradeUngerade(node *& liste, node *& odds, node *& evens)
{
    node **oddsp = &odds;
    node **evensp = &evens;

    for (node *akt = liste; akt != NULL; akt = akt->next) {
        if (akt->wert % 2 == 0) {
            *evensp = akt;
            evensp = &(akt->next);
        } else {
            *oddsp = akt;
            oddsp = &(akt->next);
        }
    }

    *oddsp = *evensp = liste = NULL;
}

Die Funktion teilt eine Zahlenliste in zwei Listen auf, eine mit geraden und eine mit ungeraden Zahlen. Soweit so gut, jedoch werden Zeiger auf Zeiger etc. verwendet und da sehe ich noch nicht ganz durch. Kann mir jemand erklären, wie sich die Adressen ändern z.B während eines Schleifendurchlaufs? Ich denke am einfachsten wärs anhand fiktiver Adressen...

Was ist eine fiktive Adresse?

Das heisst wir nehmen beliebige Adressen für das Beispiel:

// Annahme: liste-Inhalt in Adresse $2000, odds $2001, evens $2002
//liste(-Zeiger) an Adresse $1000 (Inhalt $2000)
//odds(-Zeiger) an Adresse $1001 (Inhalt $2001)
//..
void TeileGeradeUngerade(node *& liste, node *& odds, node *& evens)
{
    node **oddsp = &odds; // oddsp(-ZeigerZeiger?)an Adresse $500 (Inhalt $1001 --> Adresse von odds-Zeiger)
    // ...

Ich bin mir nicht sicher ob das was ich hingeschrieben habe überhaupt möglich ist aber damit sollte das Prinzip klar sein. Wenn jemand eine bessere Möglichkeit weiss mir klar zu machen was, wann wohin zeigt, ist das auch in Ordnung

Kann mir wirklich niemand helfen? Ich wäre schon froh wenn jemand wenigstens Kommentare hinschreiben könnte was genau abläuft...

Danke

Hallo

Ich bin neu in C++ und dabei auf folgenden Code gestossen:

struct node {
    int wert;
    node *next;
};

void TeileGeradeUngerade(node *& liste, node *& odds, node *& evens)
{
    node **oddsp = &odds;
    node **evensp = &evens;

    for (node *akt = liste; akt != NULL; akt = akt->next) {
        if (akt->wert % 2 == 0) {
            *evensp = akt;
            evensp = &(akt->next);
        } else {
            *oddsp = akt;
            oddsp = &(akt->next);
        }
    }

    *oddsp = *evensp = liste = NULL;
}

Die Funktion teilt eine Zahlenliste in zwei Listen auf, eine mit geraden und eine mit ungeraden Zahlen. Soweit so gut, jedoch werden Zeiger auf Zeiger etc. verwendet und da sehe ich noch nicht ganz durch. Kann mir jemand erklären, wie sich die Adressen ändern z.B während eines Schleifendurchlaufs? Ich denke am einfachsten wärs anhand fiktiver Adressen...

Hi!

Den Kontext indem deine Funktion ihre Arbeit macht, würde ich gern sehen - man braucht keine Referenzen
auf Zeiger (node *& liste, ...) und auch keine lokalen Zeiger auf Zeiger - einfache Zeiger reichen.
Hab deine Funktion mal in diesem Sinne verändert:

struct node { 
    int wert; 
    node *next; 
}; 

void TeileGeradeUngerade(node* liste, node* odds, node* evens) 
{ 
    for (node* akt = liste; akt != NULL; akt = akt->next)
    {
        if (akt->wert % 2 == 0) 
        { 
            evens->wert = akt->wert; 
            evens->next = evens++;
        } 
        else 
        { 
            odds->wert = akt->wert; 
            odds->next = odds++; 
        } 
    }
    odds->next  = NULL;
    evens->next = NULL;
}

int main()
{
    node liste[3] = {{1, &liste[1]},{2, &liste[2]}, {3, NULL}};
    node odds[3];
    node evens[3];

    TeileGeradeUngerade(liste, odds, evens);

}

Lass das Beispiel im Debugger laufen. Wenn du Fragen dazu hast frage!

mfg

Ich werde das nun mal genau anschauen. Allerdings muss ich dazu sagen, dass meine Variante nicht den Anspruch hat die beste Lösung zu sein. Vielmehr geht es darum zu zeigen, wie Zeiger und Referenzen an einem Extrembeispiel genau funktionieren --> typisches Schulbeispiel eben