3. Fibonacci OOP

Fibonacci OOP

  • ?

    Sehr schlechtes OOP Design.

    0
  • N

    was heißt hier schlechtes design, bei einem fibonacci-algo kannst du nunmal wenig OOPen, da ist es schon sinnlos, dass die funktion fib nicht statisch ist, schließlich hat die klasse keinerlei andere member...

    0
  • S
     

    #include <iostream>
using namespace std;

class Fibonacci
{
public:
   static int fib (int n)
    {
        if (n <= 1)
            return n;
        return fib (n-1) + fib (n-2);
    }
};

int main ()
{
    cout << Fibonacci::fib (12);
}
    0
  • S

    @SirLant:
    das macht den Code auch nicht wirklich besser

    0
  • B

    So geht OOP 💡

    #include <memory>
#include <iostream>

class Calculator {
  public:
    virtual int work() = 0;
    virtual ~Calculator() { }
};

class Calculator_factory {
  public:
    virtual Calculator* create_calculator(int n) = 0;
    virtual ~Calculator_factory_base() { }
};

class Fibonator : public Calculator {
  public:
    int work() { /* TODO: implement Fibonacci algorithm */ }
    Fibonator(int n): n(n) { }
  private:
    int n;
};

class Fibonator_factory : public Calculator_factory {
  public:
    Fibonator* create_calculator(int n);
};

Fibonator* Fibonator_factory::create_calculator(int n) {
  return new Fibonator(n);
}

int main() {
  Fibonator_factory fact;
  std::auto_ptr<Calculator> calc(fact.create_calculator(12));
  std::cout << calc->work() << std::endl;
}
    0
  • S

    Shade Of Mine schrieb:

    @SirLant:
    das macht den Code auch nicht wirklich besser

    Also ich wüsste nicht wie man ne Funktion die _imho_ nicht in ne Klasse gehört,
    besser in ne Klasse packen kann.

    Ich persönlich würde es so machen (ungetestet):

    template < typename T >
T fibonacci (const T & n)
{
    if (n <= 1)
        return n;
    return fibonacci (n-1) + fibonacci (n-2);
}

    Edit:
    Wenn ich mir Bashar's Code ansehe bevorzuge ich ne einfache Funktion in nem
    Namespace auf jeden Fall 🤡

    0
  • S

    SirLant schrieb:

    Also ich wüsste nicht wie man ne Funktion die _imho_ nicht in ne Klasse gehört,
    besser in ne Klasse packen kann.

    Und da haben wir die Lösung ja schon 🙂

    0
  • ?

    Ich glaub ich hab nen Fehler in dem code gefunden:

    return new Fibonator(n);

    Wo ist das delete? 😕

    0
  • B

    Im Destruktor von std::auto_ptr. Aber danke fürs Anschauen, dachte schon die Mühe war ganz umsonst 😉

    0
  • ?

    was macht denn auto_ptr?

    0
  • B

    auto_ptr ist ein sogenannter Smart-Pointer, der eine Besitzübertragungssemantik hat. Das heißt, er übernimmt die Verantwortung für ein Heap-Objekt und zerstört es, wenn er selbst zerstört wird. Wenn man einen auto_ptr kopiert oder zuweist, wird der Besitz und damit die Verantwortung weitergegeben -- es gibt jeweils nur einen auto_ptr, der auf ein bestimmtes Objekt zeigt (wenn man ihn nicht absichtlich falsch anwendet natürlich nur). Näheres erfährst du in jedem C++-Buch.

    0
  • S

    Wo wir gerade bei auto_ptr sind, was passiert bei Funktionsaufrufen mit dem
    Pointer als Argument, wird dann die Gültigkeit an nen auto_ptr übertragen welcher
    nach dem Aufruf nicht mehr lebt?

    Sowas meine ich:

    int main ()
{
auto_ptr<string> foo = new String ("bar");

tolle_func (foo); // void toole_func (auto_ptr<string> foo);

foo += "12"; 
}
    0
  • O

    bashar, nur so als frage:

    class Calculator_factory { 
  public: 
    virtual Calculator* create_calculator(int n) = 0; 
    virtual ~Calculator_factory_base() { } 
};

    gibts einen compiler, der die klasse mit dem dtor compiliert?

    0
  • B

    Nö, hab mich verschrieben.

    SirLant: Exakt.

    0
  • J

    @Sirlant: Du weißt aber schon, daß die Fibonacciszahlen exponentiell wachsen und die Anzahl der Funktionsaufrufe in Deiner Version proportional zur zu berechnenden Fibonacci-Zahl sind?

    0
  • D

    Das ist die richtige Lösung 😉

    #include <iostream> 
using namespace std; 
template<unsigned i> 
struct fibonacci { 
  static const unsigned result = fibonacci<i-1>::result + fibonacci<i-2>::result; 
}; 

template<> 
struct fibonacci<0> { 
  static const unsigned result = 1; 
}; 

template<> 
struct fibonacci<1> { 
  static const unsigned result = 1; 
};
int main() { 
  cout << fibonacci<9>::result; 
}

    Copyright von Rainer Baumann

    0
  • S

    Jester schrieb:

    @Sirlant: Du weißt aber schon, daß die Fibonacciszahlen exponentiell wachsen und die Anzahl der Funktionsaufrufe in Deiner Version proportional zur zu berechnenden Fibonacci-Zahl sind?

    Weiß ich, aber so ist es am kürzesten zu schreiben und sollte ja auch nur zeigen,
    wie ich so was schreiben würde.

    0
  • J

    SirLant schrieb:

    ... sollte ja auch nur zeigen,
    wie ich so was schreiben würde.

    Eben, und ich hoffe doch eigentlich, daß Du es iterativ schreiben würdest.

    0
  • S

    @pinguin: Hat aber im Prinzip wenig mit OOP zu tun? Viel eher mit Metaprogrammierung?! Nur weils hier doch um OOP ging 🙂

    MfG SideWinder

    0
  • O

    desert pinguin schrieb:

    Das ist die richtige Lösung 😉

    #include <iostream> 
using namespace std; 
template<unsigned i> 
struct fibonacci { 
  static const unsigned result = fibonacci<i-1>::result + fibonacci<i-2>::result; 
}; 

template<> 
struct fibonacci<0> { 
  static const unsigned result = 1; 
}; 

template<> 
struct fibonacci<1> { 
  static const unsigned result = 1; 
};
int main() { 
  cout << fibonacci<9>::result; 
}

    Copyright von Rainer Baumann

    2 fragen:
    1. wird das hier während des compilieren berechnet?
    2. ist das wirklich der richtige algorithmus? fiboacci war doch
    1,1,2,3,5,8,13...

    //edit aua... hab mich verguckt, die funktion berechnet die Zahl an der 9. stelle der liste oder?^^

    0
Anmelden zum Antworten