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

otze

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

groovemaster

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.