rekusion



  • hi!

    ein paar kleine fragen zu rekusion...

    void foo()
    {
       // irgendeine abbruchbedingung
       if(m_instanz_counter > 10)
              return; 
    
       class1 b1; // object instanzieren, nehmen wir man an es werden 10 objecte instanziert, dh. foo wird 10 mal aufgerufen....
    
       b1.foo();   // wie lange leben jeweils die instanzen?
    
       b1.print();  // wie oft wird hier print aufgerufen, mit welcher instanz beginnt es?
    }
    

    kann man die lebensdauer der objecte irgendwie mit schleifen grafisch darstellen?

    cu 😃



  • class foo
    {
    private:
    	std::string s1;
    	int m_instanz_count;
    public:
    	foo(std::string s2): s1(s2), m_instanz_count(0) { cout << "called konstruktor" << endl; }
    	~foo() { cout << "called desktruktor" << endl; }
    	std::string print()
    	{
    		return s1.c_str();
    	}
    	void rekusion(std::string name)
    	{
    		if(m_instanz_count > 10)
    			return;
    
    		m_instanz_count++;
    		foo foo_rekusion(name.c_str());
    		foo_rekusion.rekusion(name.c_str());
    
    		cout << foo_rekusion.print().c_str() << endl;
    	}
    };
    

    irgendwie ergibt das ne endlosschleife;-(

    cu



  • sollte doch static sein:

    class foo()
    {
    pviate:
           static int m_instanz_count;
    };
    
    int foo::m_instanz_count= 0;
    


  • klasse erweitert zur demonstation:

    class recursion
    {
    private:
    	std::string str1;
    	std::stringstream str2;
    	static int m_instance_count;
    public:
    	recursion() { cout << "called construktor for instance: " << this << endl; }
    	~recursion() { cout << "called desktruktor for instance: " << this << endl; }
    	std::string print()
    	{
    		return str1;
    	}
    	void foo()
    	{
    		if(m_instance_count > 10)
    			return;
    
    		//Sleep(1000);
    		cout << m_instance_count << endl;
    		str2.str("");
    		str2 << m_instance_count;
    		str2 >> str1;
    		recursion instanz;
    		m_instance_count++;
    		instanz.foo();
    
    		//Sleep(1000);
    		cout << instanz.print().c_str() << endl;
    	}
    };
    
    int recursion::m_instance_count = 0;
    
    int main()
    {
       instance f1;
       f1.foo();
    
       cin.get(); 
    }
    

    ausgabe:
    called construktor for instance: 0012FE28
    0
    called construktor for instance: 0012FC7C
    1
    called construktor for instance: 0012FA94
    2
    called construktor for instance: 0012F8AC
    3
    called construktor for instance: 0012F6C4
    4
    called construktor for instance: 0012F4DC
    5
    called construktor for instance: 0012F2F4
    6
    called construktor for instance: 0012F10C
    7
    called construktor for instance: 0012EF24
    8
    called construktor for instance: 0012ED3C
    9
    called construktor for instance: 0012EB54
    10
    called construktor for instance: 0012E96C

    called desktruktor for instance: 0012E96C
    10
    called desktruktor for instance: 0012EB54
    9
    called desktruktor for instance: 0012ED3C
    8
    called desktruktor for instance: 0012EF24
    7
    called desktruktor for instance: 0012F10C
    6
    called desktruktor for instance: 0012F2F4
    5
    called desktruktor for instance: 0012F4DC
    4
    called desktruktor for instance: 0012F6C4
    3
    called desktruktor for instance: 0012F8AC
    2
    called desktruktor for instance: 0012FA94
    1
    called desktruktor for instance: 0012FC7C

    😃

    warum wird eigentlich das letzte object zuerst gelöscht?;-)

    cu



  • weil der szack so aufgebaut is: last in first out.



  • kann man das sich so vorstellen?? dann wĂ€re es auch irgendwie logisch...

    void rekusion(std::string name)
    {
      ...
      ...
      foo foo_rekusion(name.c_str());
      foo_rekusion.rekusion(name.c_str());
      ...
      ...
      void rekusion(std::string name)
      {
        ...
        ...
        foo foo_rekusion(name.c_str());
        foo_rekusion.rekusion(name.c_str());
        ...
        ...
        void rekusion(std::string name)
        {
          ...
          ...
          foo foo_rekusion(name.c_str());
          foo_rekusion.rekusion(name.c_str());
          ...
          ...
    

    cu



  • Ja kann man



  • Wobei dieser Code ziemlich...ungewöhnlich...ist. Ich wĂŒrd mal kucken, ob sich das nicht durch etwas in der Art lösen lĂ€sst:

    void recursive_function_aux(int counter) {
      if(counter > max)
        return;
      // mach was
      recursive_function_aux(counter + 1);
    }
    
    void recursive_function() {
      recursive_function(0);
    }
    


  • otze schrieb:

    weil der szack so aufgebaut is: last in first out.

    Wobei der Stack hier weniger ausschlaggebend ist, sondern vielmehr die Aufrufreihenfolge der Funktionen. Die zuletzt aufgerufene Funktion wird nunmal als erste auch wieder beendet. Wie du schon sagst, das altbekannte LIFO Prinzip. Und somit wird auch die zuletzt erstellte Instanz beim Verlassen des GĂŒltigkeitsbereiches auch zuerst zerstört.


Log in to reply