spiegeln von string

Moh

Hallo,
kann mir jemand dieses kleine Programm erklaeren...ich komme nicht hinter. Habe schon alles moegliche ausprobiert... bin am verzweifeln.

#include <stdio.h>

void spiegeln(char *, int);

void main()
{
	spiegeln("Hallo", 0);
}

void spiegeln(char *s, int n)
{
	if(s[n])
	{
		spiegeln(s, n+1);
		putchar(s[n]);
	}
}

Moh schrieb:

Hallo,
kann mir jemand dieses kleine Programm erklaeren...ich komme nicht hinter. Habe schon alles moegliche ausprobiert... bin am verzweifeln.

#include <stdio.h>

void spiegeln(char *, int);

void main()
{
	spiegeln("Hallo", 0); /* Gib den "Hallo" rückwerts aus */
}

void spiegeln(char *s, int n)
{
        /* s[n] == 0 am Ende der Strings, also false */
        if(s[n])
        { /* noch nich das letzte Zeichen */
                /* rufe die Funktion nocheinmal auf, aber überspringe
                   das erste Zeichen, des Strings */
                spiegeln(s, n+1); 
                putchar(s[n]); /* gib das aktuelle Zeichen aus */
        }
        /* Wenn das letzte Zeichen erreicht ist, wir die Funktion verlassen.
           Die Funktionen geben jetzt in umgekehrter Reihenfolge, da die
           zuerstaufgerufene Funktion, zu letzt wieder drann ist, ihr Zeichen
           aus */
}

SideWinder

Das ist ein Beispiel für Rekursion, es gibt dir den String verkehrt am Bildschirm wieder aus.

"Hallo"

1. Aufruf n = 0
s[n] = H -> if(s[n]) ok
spiegeln(s,n+1) // spiegeln(s,1);

// Achtung, hier ists interessant: putchar() wird ncoh nicht aufgerufen, 
// stattdessen wird spiegeln nochmals mit neuen Parametern aufgerufen, wir sind 
// also eine Ebene tiefer (main() -> spiegeln() -> spiegeln())

2. Aufruf n = 1
s[n] = a -> if(s[n]) ok
spiegeln(s,n+1) // spiegeln(s,2);

// Immer tiefer rein bis s[n] 0 liefert, das passiert am Ende des Strings (wir
// haben ja einen nullterminierenden) also bei n = 5

// Sobald das passiert wird kein spiegeln() mehr aufgerufen, wir gehen wieder 
// eine Ebene höher. Dort wird die nächste Anweisung (also putchar() für n=4
// ausgeführt -> o wird ausgegeben). Die funktion ist dann zu Ende und wir gehen 
// wieder zurück in die letzte Funktion (eine ebene höher). dort geben wir für n 
// =3 aus, usw.

// Bis wieder zurück zur ersten spiegel()-Ebene, dort beenden wir und kommen 
// wieder in die main()-Ebene zurück. Dort wird danach weiter ausgeführt. In
// unserem Beispiel noch return 0; Damit ist auch main() beendet und wir kommen 
// wieder eine Ebene höher - auf die wir keinen Einfluss merh haben. Der OS-Gott 
// herrscht dann über unser Programm

Wenig strukturiert, aber hoffentlich verständlich

MfG SideWinder

Konfusius

man kann es auch anders erklären:

man kann einen string spiegeln, indem man alle zeichen bis auf das letzte spiegelt und dann das letzte zeichen an den anfang stellt.

"abcd"
"abc" "d"
"cba" "d"
"d" "cba"
"dcba"

das spiegeln von allen zeichen bis auf das letzte erledigt man natürlich wieder mit der spiegeln-funktion selbst! sowas nennt man dann rekursion