und zwar soll ich in Programmierungstechnik eine Funktion schreiben, die sich selbst aufruft, also rekusiv. Diese Funktion soll die Quersumme einer Zahl berechnen. Um auch sehr große Zahle berechnen zu können wollte ich die eingegebene Zahl in ein String speichern.

int einlesen(char ,int , int);

int main()
{
  // Programm Quersumme bestimmen

	char str[1000]="Testlauf";

  cout << "Bitte Zahl eingeben.";

  int a = einlesen(str[strlen(str)], strlen(str), 0);

  return 0;
};

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

Nach meinem Verständins her sollte es laufen, aber der Compiler(Microsoft Visual C++ 2005 EE) sieht das leider anders. Meldung "error LNK2019: Verweis auf nicht aufgelöstes externes Symbol ""int __cdecl einlesen(char,int,int)" (?einlesen@@YAHDHH@Z)" in Funktion "_main"." ich weiß leider nicht mehr weiter, kann mir vielleicht einer sagen was ich falsch mache?
Ich habe jetzt schon mehre möglichkeiten probiert, leider ohne Erfolg.

int einlesen(char* ,int , int);

oder

int einlesen(char a[],int , int);

über der Main-Funktion heißen...

Dann ist aber auch noch Zeile 12 falsch.

meh too late

#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);

  return 0;
};

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

Medlung "error C2664: 'einlesen': Konvertierung des Parameters 1 von 'char (*__w64 )[1000]' in 'char *' nicht möglich"

Lass hier die Klammern weg.

#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?

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));
    }
};

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.

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

#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.

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));
    }
};

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.

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.