3. rekusive Funktion

rekusive Funktion


  • Also noch mal:
    entweder "char *cstring" (bzw. besser sogar "const char *cstring") oder
    "char cstring[]" (bzw. "const char cstring[]")
    ... und dies bei beiden Funktionsköpfen (Deklaration und Definition).

    0
  • *

    Am besten std::string!

    0
  • ?

    Klappt es so?

    #include <iostream>

int einlesen(char* ,int , int);

int main()
{
  // Programm Quersumme bestimmen
  //Cquer quersumme123;
	char str[1000]="Arschkatze*";

  cout << "Bitte Zahl eingeben.";

  int a = einlesen(str, strlen(str), 0); // (GEAENDERT)

  return 0;
};

int einlesen(char* CString,int n, int Ergi){ // (GEAENDERT)
    if (n <= 1){
        //
        return Ergi;    
    }
    else{
        int lala = (int)(*CString[--n]);
        einlesen(CString, n,  Ergi += (48 - lala)); // (GEAENDERT)
    }
};

    Was ich mich frage: Was soll das ganze?

    0
  • F

    super Danke 🙂 , er compiliert das Programm jetzt ohne Fehler. Aber es scheint das ich noch ein Logikfehler oder ähnliches drin habe.

    Beim susführen erscheinen die Meldungen:

    ""pt2-1.exe": "C:\kopie server\Schule\Studium\Programmierung\c\pt2-1\debug\pt2-1.exe" geladen, Symbole wurden geladen.
    "pt2-1.exe": "C:\WINDOWS\system32\ntdll.dll" geladen, Keine Symbole geladen.
    "pt2-1.exe": "C:\WINDOWS\system32\kernel32.dll" geladen, Keine Symbole geladen.
    "pt2-1.exe": "C:\WINDOWS\WinSxS\x86_Microsoft.VC80.DebugCRT_1fc8b3b9a1e18e3b_8.0.50727.762_x-ww_5490cd9f\msvcp80d.dll" geladen, Keine Symbole geladen.
    "pt2-1.exe": "C:\WINDOWS\WinSxS\x86_Microsoft.VC80.DebugCRT_1fc8b3b9a1e18e3b_8.0.50727.762_x-ww_5490cd9f\msvcr80d.dll" geladen, Keine Symbole geladen.
    "pt2-1.exe": "C:\WINDOWS\system32\msvcrt.dll" geladen, Keine Symbole geladen.
    Das Programm "[4640] pt2-1.exe: Systemeigen" wurde mit Code 0 (0x0) beendet."

    PS: Was merkwürdig ist, das Ergebnis ist richt was rauskommt, nur negativ statt positv. 😕
    Wenn ich ein anderen Compiler verwende(Dev-C++ zeigt er beim compilieren und beim ausführen keine direkten Fehler an), die Werte sind wieder neg. und das diesmal beim letzten Funktionsaufruf eine falsche Zahl erscheint.

    Was ich mich frage: Was soll das ganze?

    Wir sollen halt üben wie man eine rekusive Funktion schreibt(also eine Funktion die sich selbst aufruft).

    Bei jedem Funktionsaufruf werden die aktuellen Variablen im ,,Stack‘‘ gespeichert.

    Der Vorteil ist glaub ich das die Berechnung schneller erfolgt als bei einer normalen Fnktion 🙄

    int einlesen(char[],int , int);
int main()
{
  // Programm Quersumme bestimmen
  char str[1000]="123456";

  cout << "Bitte Zahl eingeben.";

  int a = einlesen(str, strlen(str), 0);
  cout << "Ende: " << a;
  return 0;
};

int einlesen( char CString[],int n, int Ergi){
    if (n == 0){
        return Ergi;    
    }
    else{
		int lala = (int)(CString[--n]);
		cout << "\nOut: " << Ergi;
        einlesen(CString, n,  Ergi += (48 - lala));
    }
};
    0
  • ?

    Für mich sieht das so aus, als würde der Debugger einige Symbole aus deinem Programm nicht laden können. Das sollte aber kein Problem mit deinem Programm sein. Bin mir aber nicht sicher.

    0

  • Du addierst ja auch negative Werte.
    Nimm "lala - 48" bzw. "lala - '0'".

    0
  • K

    fluffy17 schrieb:

    Was ich mich frage: Was soll das ganze?

    Wir sollen halt üben wie man eine rekusive Funktion schreibt(also eine Funktion die sich selbst aufruft).

    Bei jedem Funktionsaufruf werden die aktuellen Variablen im ,,Stack‘‘ gespeichert.

    Der Vorteil ist glaub ich das die Berechnung schneller erfolgt als bei einer normalen Fnktion 🙄

    Hmm. Nein, überhaupt nicht. Scheint ja sehr erfolgreicher Kurs zu sein, wenn der Sinn so klar rüberkommt. 😉

    Also, das ist ein Thema, mit dem Du Dich auseinandersetzen solltest: Was bringt Rekursion? Ist übrigens eine exzellente Kursfrage an den Dozenten. Wäre mal gespannt, ob er das beantworten kann.

    Davon abgesehen finde ich Deine Rekursionsfunktion ganz schön kompliziert. Das geht in einer einzigen Zeile.

    #include <iostream>
#include <string>

using namespace std;

int digit_sum(string::const_iterator begin, string::const_iterator end) {
    return begin == end ? 0 : *begin - '0' + digit_sum(begin + 1, end);
}

int main(int argc, char* argv[]) {
    if (argc != 2)
        return 1;

    string number = argv[1];
    cout << "Quersumme: " << digit_sum(number.begin(), number.end()) << endl;
}

    Kompiliert und aufgerufen (auf der Konsole, hab gerade kein Windows):

    $ g++ -pedantic -Wall quer.cpp -o quer
$ ./quer 12345
Quersumme: 15

    Hier bekommt die Rekursion ein Paar von Zeigern übergeben, nämlich das Anfang und das Ende des Strings (genauer gesagt einen Zeiger auf das erste und einen *hinter* das letzte Zeichen). In der Funktion wird dann geschaut, ob der übergebene String leer ist: dann wird 0 zurückgegeben. Ansonsten wird die erste Ziffer ermittelt ( *begin - '0' ) und zur Quersumme des restlichen Strings addiert (ah, Rekursion!). Der „restliche String“ wird einfach dadurch ausgedrückt, dass der Beginn-Zeiger um eins erhöht wird, also auf das nächste Zeichen weitergerückt wird.

    0
  • F

    also dein Quelltext ist wirklich sehr kurz ^^
    Ich habe die Formel bei meinem Quelltext abgeändert und jetzt ist es in positven Bereich 😃 Danke schön

    Am Montag habe ich wieder Vorlesung bei Prof. da werde ich nochmal nachfragen wenn sich die Möglichkeit dafür ergibt.

    0
  • ?

    Noch eine "komplizierte" Variante:

    #include <iostream>
#include <vector>
#include <algorithm>
#include <cstdlib>
#include <ctime>

namespace detail {
unsigned int digit_sum_tr( char* first, char* last, unsigned int acc ) {
  return first == last
    ? acc
    : digit_sum_tr(first+1, last, acc + *first - '0'); }}

unsigned int digit_sum_tr( char* first, char* last ) {
  return detail::digit_sum_tr(first, last, 0); }

int digit_sum( char* begin, char* end ) {
    return begin == end ? 0 : *begin - '0' + digit_sum(begin + 1, end);
}

inline int random( int min, int max ) { return min + std::rand() / (RAND_MAX / (max - min) + 1 ); }
char make_random_digit()              { return static_cast<char>(random('0', '9')); }

int main() {
  std::srand(std::time(0));
  std::size_t const ndigits = 1000000;
  std::vector<char> number(ndigits);
  std::generate_n(number.begin(), ndigits, make_random_digit);

  std::cout << "digit_sum_tr:\t" << digit_sum_tr(&number[0], &number[0]+ndigits) << std::endl
            << "digit_sum:\t"    << digit_sum   (&number[0], &number[0]+ndigits) << std::endl;
}

    Kompiliert und ausgeführt:

    digit_sum_tr:   4001537
digit_sum:
Process returned -1073741819 (0xC0000005)   execution time : 0.063 s
Press any key to continue.
    0
  • K

    Hi 'f, jetzt musst Du natürlich noch erklären, dass das Suffix 'tr' für Tail Recursion steht und warum das so einen enormen Unterschied macht.

    0
  • F

    🙂 ich habe heute noch ein Feedback zu meinem Programm bekommen, das die Funktion noch nicht rekursiv war.

    hier der abgeänderter Code:

    #include <iostream>
#include <string.h>

using namespace std;
int einlesen(char[],int);

int main()
{
  // Programm Quersumme bestimmen
  char str[1000]="123456";

  cout << "Bitte Zahl eingeben: ";
  cin >> str;

  int a = einlesen(str, strlen(str));
  cout << "\nEnde: " << (a);

  return 0;
};

int einlesen(char CString[],int n){
    if (n == 0){
        return 0;    
    }
    else{
		int lala = (int)(CString[--n])-48;
		//cout << "\nAddition: " << Ergi;
        return (lala + einlesen(CString, n));
    }
};
    0
  • K

    fluffy17 schrieb:

    🙂 ich habe heute noch ein Feedback zu meinem Programm bekommen, das die Funktion noch nicht rekursiv war.

    Von wem?

    Ich kann Dir versichern, dass jeder bisher gepostete Code in diesem Thread rekursiv war.

    0
  • F

    Konrad Rudolph schrieb:

    fluffy17 schrieb:

    🙂 ich habe heute noch ein Feedback zu meinem Programm bekommen, das die Funktion noch nicht rekursiv war.

    Von wem?

    Ich kann Dir versichern, dass jeder bisher gepostete Code in diesem Thread rekursiv war.

    😮
    wir haben in der Fachhochschule auch Übungsstunden und da hat der verantwortliche mein Programm angesehen. Er meinte das das Prinzip der Rekursion nicht zum vorschein kommt, da das Ergebnis immer wieder neu an die Funktion übergeben wird(welches bei der Rekursion nicht benötigt wird). Da er die Ergebnisse in Stack ablegt und dann wieder von hinten(also das letzte Ergebnis) bis hin zum ersten addiert.
    http://grapen-stieten.de/mibt/aufgabe1.pdf

    Vorher hat er beim letzten aufruf der Funktion, das Ergebnis ausgegeben. Und ist den Weg nicht wieder zurück gegangen, (also er hat es nicht so berechnet wie es in Stack abgelegt wurde).
    Nach der Zeichung hat er das Ergebnis bereits bei den Punkt "abbruch der Rekursion" zurüchkegeben.

    0
  • ?

    Dann hast du ihn entweder falsch verstanden, oder "der Verantwortliche" hat keine Ahnung wovon er spricht.

    0
  • F

    Also ich denke schon das ich ihn richtig verstanden habe.
    Er hat mir die Funktionaufrufe auch aufgemalt und meinte "ab den Punkt bricht er bei dir die Rekursion ab und geht den weg nicht wieder zurück".

    0
Anmelden zum Antworten