Anzahl der Aufrufe einer Funktion bestimmen

refeilras

Moin, also ich habe eine Funktion erstellt und möchte neben der eigentlichen Rechnung noch bestimmen wie oft auf diese Funktion zugegriffen wurde.

Das hier ist ist meine Funktion:

long fzl(long n) {
    if(n)
        return (n <= 1) ? n : fzl(n-2) + fzl(n-1);
    return 0;
}

Ich habe es folgender Maßen versucht:

long fzl(long n long sum) {
    if(n)
        return (n <= 1) ? n : (fzl(n-2) + fzl(n-1)) && sum++;
    return 0;
}

Das funktioniert aber leider nicht.

Wäre nett, wenn jemand ne Idee hätte

Dein Versuch compiliert noch nicht mal.

Schau dir mal static Variablen in Funktionen an.

refeilras

Stimmt es denn, dass die Summierung in die return-Anweisung integriert wird?

long fzl(long n, static int sum) {
    if(n)
        return (n <= 1) ? n : ((fzl(n-2) + fzl(n-1)) && sum++);
    return 0;
}

Ist das komplett falsch oder ist wenigstens der Ansatz richtig?

Klar ist das falsch, da du bei deinen rekursiven Aufrufen nur einen Paramter an fzl übergibst.

Wenn du den Paramter sum übergibst, ist das doch auch völlig sinnlos.

long fzl(long n) {
  static long sum = 0;

  if(n==LONG_MIN) 
    return sum;
  else {
     ++sum;
// dein Code hier
  return 0;
  }
}

Dann rufst du die Funktion mit fzl(LONG_MIN) auf und bekommst die Anzahl der Aufrufe zurück.

oder

long fzl(long n, long *psum) {
  static long sum = 0;

  ++sum;
  if(psum) 
    *psum= sum ;

// dein Code hier  ... ((fzl(n-2,NULL) + fzl(n-1,NULL) ...

  return 0;
  }
}

Wenn psum auf eine long-Variable zeigt, wird dort der Wert abgelegt.
Wenn der Zeiger NULL ist, passiert nichts

refeilras

Ok erstmal besten Dank!

Ich habe das jetzt so:

long fzl(long n) { 
    static long sum = 0; 

    if(n==LONG_MIN ) 
        return sum; 
    else { 
        ++sum; 
        if (n)
            return (n <= 1) ? n : fzl(n-2) + fzl(n-1);      

        return 0; 
    } 
}

Aber bei der 2. Zahlenfolge zeigt der mir an, dass 4 mal auf die Funktion zugegriffen wurde und die restlichen Summen der darauf folgenden Summierungen kommen mir auch etwas zu hoch vor. Kann das sein oder ist da noch irgendwas falsch?

Die Funktion zählt sämtliche Aufrufe seit Programmstart.
Was anderes war so nicht ersichtlich.

Du kannst noch ein

if(n==LONG_MAX)
    sum = 0;

einbauen

Offensichtlich soll das Programm die Fibonacci-Zahlen durch Rekursion berechnen.

Wenn man genau hinschaut, ruft fzl(n-1) nach dem ersten Schritt fzl(n-2) usw. auf, was dann aber beim zweiten Summanden wiederholt wird. Somit wird die Fibonacci-Zahlenfolge zweimal berechnet, einmal vollständig, einmal eine Zahl weniger.

Hoffentlich hat der Aufgabensteller damit nur demonstrieren wollen, wo man eine Rekursion nicht einsetzen soll.

Das Programm dient nur dazu, den Wärmetot der Erde zu beschleunigen (oder physikalischer: die Entropie zu erhöhen).

Die bessere Lösung funktioniert iterativ:

unsigned long Fibonacci_iterativ(unsigned long nN) {
  unsigned long nFib1=0,nFib2=1,nFib,nI;
  if (nN==0) {return 0;}
  if (nN==1) {return 1;}
  for (nI=2;nI<=nN;nI++) {
    nFib=nFib1+nFib2;
    nFib1=nFib2;
    nFib2=nFib;
  } /*for*/
  return nFib;
} /*Fibonacci_iterativ*/

Ok, ich war zu faul, die Variablennamen usw. an Deine Lösung anzupassen.

Noch eine schöne Übung: Bei welchem nN sprengen die Zahlen den Zahlenbereich?