3. Funktionstemplate rekursiv aufgerufen?

Funktionstemplate rekursiv aufgerufen?

  • J

    Hi Leute 🙂

    Bereite mich momentan auf meine kommende Klausur in Informatik vor und wollte 2 einfache Sachen implementieren (Arithmetisches + Harmonisches Mittel). Weil ich aber gleichzeitig rekursion + Templates üben wollte, dachte ich ich könnte es kombinieren.

    Jetzt mein Problem: Ist es möglich, dass ich in Templates garnicht rekursiv arbeiten kann, oder vielmehr immer wieder ein neues Objekt erstellt wird?

    So in der Art:

    int durchlauf=0;
template <class T>
T arith(int size){
cout << size << endl;
cout << ++durchlauf << endl;
if (size==10) return 0;
return arith<double>(size++);
}

    Aufgerufen in der main wirds einfach mit arith<double>(1);

    Mir ist klar, dass die Funktion jetzt so nix macht, aber habe halt gemerkt, dass die Rekursionsverankerung nicht greift.

    Denkfehler meinerseits oder was anderes? 🙂

    Danke für die Hilfe!

    0
  • B

    Nö, das geht wunderbar.

    Eventuell solltest du bei deinem Funktionsaufruf ++size statt size++ benutzen? Sonst wird das nämlich tatsächlich nichts (mal abgesehen von einer Endlosen Rekursion die irgenwann in einem Stack Overflow resultiert ;)).

    0
  • J

    Omg.

    Ja äh kurz und knackig 😉 Danke. Läuft jetzt 😉

    Was kann man schöner machen bei dem Code (abgesehen davon, dass da Rekursion nicht wirklich schön ist, oder? : /)

    T arith(T *input, int size){
	T static sum=0;
	if(*input=='\0') return sum/size;
	sum+=*input;
        return arith<double>(++input, size);
}
    0
  • Mod

    jakap schrieb:

    Was kann man schöner machen bei dem Code (abgesehen davon, dass da Rekursion nicht wirklich schön ist, oder? : /)

    Eigentlich sin d sowohl Templates als auch Rekursion für die Berechnung des Mittelwertes ziemlich unschön, da sie keinerlei Mehrwert bringen. Der einzig sinnvolle Templateparameter ist double und die verwendete Rekursion ist bloß eine umständliche Form der Schleife.

    Da es aber rein um das Üben von Templates und Rekursion geht: Gut umgesetzt, besser wird's kaum gehen. 👍

    0
  • J

    Okay besten Dank

    0
  • J

    Hab leider nochmal ne Frage:

    template <class T>
void swap(T &a, T &b){
	T temp;
	temp=a;
	a=b;
	b=a;
}

template <class T>
void dreh_um(T *array, int anzahl){
	for(int i=0;i<anzahl;i++){
		swap<T>((T)array[i], (T)array[anzahl-i]);
		anzahl--;
	}
}

    error: no matching function for call to ‘swap(int, int)’

    Ich hab in dreh_um extra schon gecastet (online gefunden..), weil er sonst nicht wusste, welche Methode er nehmen soll. Aber so läufts eben auch nicht, wieso findet er denn swap(int) nicht?

    Danke im Voraus 🙂

    edit: Das array umdrehen ansich klappt hier natürlich noch nicht, hab vergessen 1 abzuziehen und durch 2 zu teilen 😉

    0
  • Mod

    Lass den (völlig unnötigen) Cast weg, dann wird es funktionieren. Das liegt daran, dass swap() int-Referenzen erwartet, das Ergebnis des Casts kann aber nicht in eine Referenz umgewandelt werden.

    Dein swap() ist übrigens falsch, da solltest du noch mal einen Blick drauf werfen.

    0
  • J

    Ja, zu schnell geschrieben, muss natürlich b=temp sein 😃

    Leider leider funktionert es nicht ohne cast, deswegen habbich den ja erst gegoogelt 😉

    template <class T>
void swap(T &a, T &b){
	T temp;
	temp=a;
	a=b;
	b=temp;
}

template <class T>
void dreh_um(T *array, int anzahl){
	for(int i=0;i<anzahl/2;i++){
		swap<T>(array[i], array[anzahl-1-i]);
	}
}

    ../reihenfolge.cpp: In function ‘void dreh_um(T*, int) [with T = int]’:
../reihenfolge.cpp:33:   instantiated from here
../reihenfolge.cpp:22: error: call of overloaded ‘swap(int&, int&)’ is ambiguous
../reihenfolge.cpp:12: note: candidates are: void swap(T&, T&) [with T = int]
/usr/include/c++/4.4/bits/move.h:76: note:                 void std::swap(_Tp&, _Tp&) [with _Tp = int]

    Danke für die Hilfe! 👍

    0
  • Mod

    DAS ist ein ganz anderer Fehler. Zum einen hast du eine Funktion swap im globalen Namensraum definiert, zum anderen hast du offenbar den Namensraum std , welcher auch eine Funktion swap enthält, in den globalen Namensraum ausgeleert.

    Was kann man dagegen tun? Zuerst mal solltest du verstehen, warum das Problem überhaupt auftritt. Da es schon spät ist, mag ich jetzt keine ausführliche Erklärung geben, sondern dir ein paar Frage zur Recherche geben: Was sind Namensräume? Wozu sind sie gut? Was macht using namespace ? Was ist das gefährliche an using namespace in Headerdateien? Viele der antworten kannst du auch hier im Forum finden.

    Mögliche Abhilfen:
    a) Irgendwo hast du ein using namespace std oder using std::swap . Entferne dies. Dies ist generell eine gute Idee, wenn das using namespace in einem Header stehen sollte.
    b) Gib deiner Funktion einen anderen Namen. Die einfachste Form der Abhilfe, aber so lernst du nichts Neues.
    c) Mach einen eigenen Namensraum für deine Funktionen und gib dann den vollständigen Namen an, wo sie benutzt werden. Dies ist sicherlich die lehrreichste Form der Abhilfe.

    0
  • J

    aaah mir war überhaupt nicht klar, dass in std:: eine Funktion swap existiert..

    Ja, ich kenne Namensräume, kenne die Gefahren (zumindest in der Theorie, hier hats geknallt), falls using namespace in ner Headerdatei ist hab ich möglicherweise Pech und kann keine anderen Namensräume mehr verwenden, etc.

    c) habe ich noch nie gemacht, hast du Recht. Haben wir auch in der Uni noch nicht gemacht, aber es schadet da nicht mich zu informieren.

    Also ganz herzlichen Dank für deine kompetente, freundliche und wie immer hier unglaublich schnelle Hilfe 🙂

    0
Anmelden zum Antworten