Rekursion ist doch was feines.

Gibt es überhaupt "einen" Gott

[10tacle]

Zitat von Cool Master

Gibt es überhaupt "einen" Gott

Auf diese Frage lautet die Antwort "NEIN"!

@kerri, mein Respekt!

[Pirke]

Zitat von 10tacle

Auf diese Frage lautet die Antwort "NEIN"!

Kannst du es beweisen???
Ok, lassen wir das Thema, das gab es hier schon zur genüge...

[Qndre]

WINE = WINE Is Not an Emulator

WINE ist doch aber eher WinE (Windows Emulation)... Das mit dem Stein iss gut. Eigentlich keine Rekursion aber ne tolle philosophische Fragestellung.

[HyperY2K]

Zitat von Qndre

Ist der Satz wahr oder unwahr? Um die Rekursion zu verstehen muss man erst einmal die Rekursion verstehen. Definition des Begriffes Rekursion: Siehe Rekursion.

Das ist kein ! Denkt einfach mal ein wenig drüber nach...

also wenn der Satz wahr ist, dann ist er auch unwahr und somit hätte man mit einem Rechner ein Problem, weil man sich ne tolle Endlosschleife gebaut hat, Oder?

[EoN]

Zitat von HyperY2K

also wenn der Satz wahr ist, dann ist er auch unwahr und somit hätte man mit einem Rechner ein Problem, weil man sich ne tolle Endlosschleife gebaut hat, Oder?

Zu einer richtig programmierten Rekursion gehört auch immer eine Abbruchbedingung die immer in einer endlichen Zeit erreicht werden muss (nachweisbar über Vollständige Induktion).
An sonsten hast du dir, wie du richtig festgestellt hast, eine Endlosschleife gebaut.

[HyperY2K]

Zitat von EoN

Zu einer richtig programmierten Rekursion gehört auch immer eine Abbruchbedingung die immer in einer endlichen Zeit erreicht werden muss (nachweisbar über Vollständige Induktion).
An sonsten hast du dir, wie du richtig festgestellt hast, eine Endlosschleife gebaut.

Wie wärs: Machen wir ne VI mal im Forum zusammen...

[Shadow2000]

Das will ich mal sehen, wie du eine unendlich laufende Rekursion hinkriegst.

[Jlagreen]

Zitat von Shadow2000

Das will ich mal sehen, wie du eine unendlich laufende Rekursion hinkriegst.

wie soll man das denn verstehen?

sollte doch ganz einfach sein (in C):

void bla();

int main()
{
   bla();
   return 0;
}

void bla()
{
   bla();
}

ansonsten hat EON natürlich recht und jeder halbwegs intelligente Programmierer wird da ne Abbruchbedingung setzen

allerdings war das ne "programmierte" unendliche laufende Rekursion, ob man sowas auch in nem einfachen Satz hinkriegt, weiss ich ned

btw:
was ist "VI"?
--> steh da grad aufm Schlauch

[Shadow2000]

Und wo soll der unendliche Stackplatz für eine unendliche Rekursion herkommen.

[HyperY2K]

Zitat von Jlagreen

wie soll man das denn verstehen?

sollte doch ganz einfach sein (in C):

void bla();

int main()
{
void bla ()
{
bla();
}
}

ansonsten hat EON natürlich recht und jeder halbwegs intelligente Programmierer wird da ne Abbruchbedingung setzen

allerdings war das ne "programmierte" unendliche laufende Rekursion, ob man sowas auch in nem einfachen Satz hinkriegt, weiss ich ned

btw:
was ist "VI"?
--> steh da grad aufm Schlauch

BTW: dein prog geht nicht.....
du kannste funktionen nur ausserhalb von main anlegen:

int test(void)
{
   test();
   return 0; 
}

int main(void)
{
   test();
   return 0;
}


VI = Vollständige Induktion

[Shadow2000]

Und selbige am besten noch aufrufen.

Wenn du die Funktionsdefinition und den Prototyp vertauschst, gehts sogar ohne das man nur ein weiteres Zeichen einfügen musst.

[Jlagreen]

Zitat von HyperY2K

BTW: dein prog geht nicht.....
du kannste funktionen nur ausserhalb von main anlegen:

jepp stimmt, aber ich wollts jetzt auch ned so genau nehmen , eigentlich wollte ich die main Funktion gar nicht schreiben und nur eine Funktion, die sich selbst aufruft, habe aber im nachhinein ohne nachzudenken schnell noch main geschrieben, aber ich denke mal, dass die Intension durchgedrungen ist

naja auf nen VI hätte ich jetzt keine Lust, da ich sowas schon ne Weile nicht mehr gemacht hab

EDIT:
btw hab mein Beispiel "verbessert", so stimmts doch nun oder?

[Shadow2000]

Dann kompilier das mal und lasses laufen, sehr lange wird der nicht laufen

[HyperY2K]

Zitat von Shadow2000

Dann kompilier das mal und lasses laufen, sehr lange wird der nicht laufen

jepp, entweder bekommst du ne fehlermeldung oder dein os schmiert ab..

[Shadow2000]

Hab das grad mal mit einem int als Parameter probiert. Der Stack hat grad mal für 4788 Rekursinen gereicht .

Das gibt aber nur im Debug-Modus nen Fehler, beim normalen lauf bricht er einfach Fehler- und Exceptionlos ab.

[EoN]

Klar, in C gehts nicht, weil irgendwann die Variablen überlaufen, aber in Funktionaler Programmierung ists eigentlich ganz einfach. Hier mal das ganze in Haskell als Beispiel:

unendlich :: Int -> Int
unendlich x = unendlich x

Und wenn der PC nicht gestorben ist, dann rechnet er noch heute

[tele]

warum soll rekursion in C net gehen? in haskell könnte es daran liegen, dass rekursion das einzige ist was es gibt, oder gibs da schon schleifen?

[Jlagreen]

Zitat von tele

warum soll rekursion in C net gehen? in haskell könnte es daran liegen, dass rekursion das einzige ist was es gibt, oder gibs da schon schleifen?

ich denke EON hat ihr eher die "unendlich laufende Rekursion" gemeint, da in C schnell der Stack zb. zu Ende geht

Rekursion selbst geht in C natürlich einwandfrei (wäre ja auch schlimm, wenn nicht)

[EoN]

Zitat von tele

warum soll rekursion in C net gehen? in haskell könnte es daran liegen, dass rekursion das einzige ist was es gibt, oder gibs da schon schleifen?

Nein es gibt keine Schleifen. Das würde aber auch den Sinn der funktionalen Programmierung ad absurdum führen, da dort nur Ausdrücke ausgewertet werden.

Zitat von Jlagreen

ich denke EON hat ihr eher die "unendlich laufende Rekursion" gemeint, da in C schnell der Stack zb. zu Ende geht

Das ist ja das tolle in Haskell, es gibt keine wirklichen Stack/Variablenbeschränkungen, da die Programmiersprache nicht so sehr Maschinennah ist wie C.
Man kann z.B. unendlich lange Listen definieren. Genügend Arbeitsspeicher vorrausgesetzt, sind genau so unendlich große Variablen möglich.

Daher funktioniert dann die Rekursion auch "unendlich" oft und wird nicht (so sehr) durch Maschinenbeschränkungen eingeschränkt.
Wobei ich auch sagen muss, dass bei mir mit gcc 126 594 Rekursionen möglich sind, bevor das Programm abbricht. Für den Hausgebrauch dürfte das normalerweise ausreichen

[kerri]

Zitat von EoN

[...]
Wobei ich auch sagen muss, dass bei mir mit gcc 126 594 Rekursionen möglich sind, bevor das Programm abbricht. Für den Hausgebrauch dürfte das normalerweise ausreichen

Wie messt Ihr das? Ich habs einfach mal laufen lassen, mit ner print anweisung, die alle 10000 rekursionen mal 'piep' sagt, also so:

void bla()
{
    i++;
    if (i%10000 == 0)
	printf("rekursion nr %d\n",i);
    bla();
}

und das muellte mir rasend schnell (in etwa 2 Minuten) den Speicher (incl SWAP insgesamt etwa 800MB waren frei) zu, und das Ende vom Lied war dann, das fast ueberhaupt nix mehr reagierte (Ctrl+C hat nach 2 Minuten angesprochen) und die letzten Zeilen waren:

[...]
rekursion nr 61810000
rekursion nr 61820000
rekursion nr 61830000
rekursion nr 61840000
rekursion nr 61850000
rekursion nr 61860000
rekursion nr 61870000
rekursion nr 61880000
cccbash: [5474: 1] tcsetattr: Interrupted system call
Terminated

Also sollte er fast 62 Millionen rekursionen geschafft haben? Kann man das noch anders ermittlen?

Gruesse, kerri

PS.: so langsam macht der Thread ja Sinn *staun*

[EoN]

Interessant wie unterschiedlich das die Compiler handhaben.

Ausgabe von deiner Funktion:

C:\Dokumente und Einstellungen\XXX\Desktop>test
rekursion nr 10000
rekursion nr 20000
rekursion nr 30000
rekursion nr 40000
rekursion nr 50000
rekursion nr 60000
rekursion nr 70000
rekursion nr 80000
rekursion nr 90000
rekursion nr 100000
rekursion nr 110000
rekursion nr 120000

C:\Dokumente und Einstellungen\XXX\Desktop>

Mein Programmcode sieht so aus:

#include <stdio.h>

void bla();

unsigned int i;
int main()
{
   i = 0;
   bla();
   printf("%i\n", i);
   return 0;
}

/*void bla()
{
	i++;
	printf("%i\n", i);
   bla();
}*/

void bla()
{
    i++;
    if (i%10000 == 0)
	printf("rekursion nr %d\n",i);
    bla();
}

Compiliert mit gcc aus cygwin.

[kerri]

Ok, naechste Version, diesmal mit uebergabe der Variablen:

#include <stdio.h>

void bla(unsigned int i);

int main()
{
    unsigned int i=0;
    bla(i);
    return 0;
}

void bla(unsigned int i)
{
    i++;
    if (i%10000 == 0) printf("rekursion nr %d\n",i);
    bla(i);
}

Ausgabe diesmal:

[...]
rekursion nr 30940000
rekursion nr 30950000
rekursion nr 30960000
rekursion nr 30970000
 
kerri@assam:~>

Hm, nur 31 mille muellt nicht ganz so effektiv den Speicher zu, wie die andere Version Aber hat sich dafuer auch etwas friedlicher beendet

Wobei ich es eigentlich erstaunlich finde, das sich die Kiste hinterher wieder faengt.

Gruesse, kerri

EDIT:
kerri@assam:~> gcc --version
gcc (GCC) 3.3.3 (SuSE Linux)

[TwinView]

Komme mit beiden Versionen auf 130k.

[EoN]

Hm.. wirklich interessant. Anscheinend ist der Windowsport von gcc nicht mal halb so mächtig wie die original Linuxversion:

$ gcc --version
gcc (GCC) 3.3.3 (cygwin special)

PS: Mit der Variablenübergabe, bekomm ich genau die gleichen Ergebnisse wie ohne.