Frage zu Code

bool foo(int x)
{
  x--;
  std::cout<<x<<" ";

  foo(x);                      //Dachte mir ich bau die Rekursion hier ein 

	if(x>0)return 1;
	else {return 0;}

}

mit der Platzierung der Rekursion scheints irgendwie auch net hinzuhaun

Kóyaánasqatsi

Die Rekursion hat da gar keinen Zweck. Zu foo:
-x(15) wird dekrementiert (14)
-wenn x(14) größer ist als 0, gebe 1(true) zurück

Und da foo() == 1 ist, wird die while()-Schleife nie enden (same as while(true)). Ich glaube du hattest eher eine Referenz auf y vor:

bool foo(int &x)

Nexus

Verwende nächstes Mal bitte einen brauchbaren Threadtitel.

Was möchtest du genau erreichen? Eine Funktion, die sich rekursiv mit dekrementiertem Argument aufruft und bei Null aufhört? In C++ ist es eigentlich unüblich, für sowas Rekursion zu verwenden. Eine Schleife braucht weniger Code und ist schneller. Aber es kann natürlich dennoch eine gute Übung sein.

void foo(int x)
{
    std::cout << x << " ";

    if (x == 0)
        return;
    else
        foo(x-1);
}

hustbaer

Bei sowas rekursiv zu werden halte ich nun auch wieder für übertrieben. Zumindest wenn man in C++, und nicht in Lisp/Scheme/... programmiert.

ich hab mal noch eine kurze Frage. Will deswegen keinen neuen Thread anlegen.

Ich hab 2 Zeiger die beide auf denselben int Wert zeigen.

z.B. int x;

int* y=&x;
int* z=&x;

jetzt mach ich folgendes :

free(y);

das müßte doch eigentlich zum Programmabsturz führen weil z auch auf x zeigt ??

knivil

Nur wenn du z danach weiterverwendest. Und undefiniertes Verhalten != Programmabsturz. Auch darfst du nur free auf Zeiger aufrufen, wenn der Speicher mittels malloc angefordert wurde.

int* y=new int;

jetzt zeigt y irgendwohin oder ?

Hier bekomm ich auch nen Fehler

void main(void)
{
    int x=5;
	int* y=new int;
	int* z=new int;

	y=&x;
	z=&x;

	delete y;

}

und übrigends auch hier assertion failure

#include <iostream>

void main(void)
{
    int x=5;  int u=7;
	int* y=new int;

    y=&x;
	delete y;
    y=&u;

}

drakon

Ja, klar, weil x ein automatisches Objekt ist und du es indirekt zerstören willst (respektive es 2x zerstört wird).

Nexus

blurry43525 schrieb:

int x;

int* y=&x;
int* z=&x;

free(y);
das müßte doch eigentlich zum Programmabsturz führen weil z auch auf x zeigt ??

Nein, nicht deswegen. Aber du erzeugst undefiniertes Verhalten, weil du ein automatisches Objekt mit free() freigeben willst. In C++ gibt es in den allermeisten Fällen kein Bedarf für malloc() und free() , verwende die C++-Speicheroperatoren new und delete !

Was deinen anderen Code angeht:

// Der Rückgabetyp von main ist int und NICHT void!
void main(void)
{
    int x=5;
	int* y=new int;
	int* z=new int;

	y=&x; // Memory Leak 1
	z=&x; // Memory Leak 2

	delete y; // delete auf automatisches Objekt
}

Ich empfehle dir, den Artikel über Zeiger in C++ nachzulesen. Dir fehlt offenbar noch ein wenig das Verständnis.

#include <iostream>

class A{

public:
	void C(){};
	void D(){};
	void E(){};
	};

class B:public A{
public:
	void F(){};
	void G(){};
	void H(){};
};

void main(void)
{

	A* x=new B;

	//Der Zeiger hat nur auf Funktionen aus A Zugriff
	//aber nicht aus B, obwohl er auf B zeigt
}

SeppJ

//Der Zeiger hat nur auf Funktionen aus A Zugriff
  //aber nicht aus B, obwohl er auf B zeigt

Ich empfehle dir, dir etwas zum Thema Zeiger und Polymorphie durchzulesen. Dir fehlt offenbar noch ein wenig das Verständnis.

Dravere

SeppJ schrieb:

//Der Zeiger hat nur auf Funktionen aus A Zugriff
  //aber nicht aus B, obwohl er auf B zeigt
Ich empfehle dir, dir etwas zum Thema Zeiger und Polymorphie durchzulesen. Dir fehlt offenbar noch ein wenig das Verständnis.

Und vielleicht noch die Frage dazustellen:
Auf was zeigt "A* x"?

Grüssli