In C/C++ gibt es ja anscheinend 2 möglichkeiten einer variablen zu erstellen.

a) "automatisch"

int a;

b) "manuell"

int *a = new int;

Nun ist bei b) klar wann der Speicher wieder freigegeben wird: erst bei

delete a;

... sonst haben wir ein Speicherleck.

Nun aber a)!
Beispiel:

char *stringfunction()
{
  char *string = "Test"; // equivalent zu char string[5] = "Test"; oder einer Einzelzuweisung
return string;
}

int *intfunction()
{
  int i = 1;
  return &i;
}

void main()
{
  char *stringtest;
  stringtest = stringfunction(); // FEHLER? ist der speicherbereich nicht schon freigeben?

  int *inttest;
  inttest = infunction(); // FEHLER? ist der speicher nicht schon freigegeben?
}

Allgemein lautet die Frage: WANN werden a) Variablen wieder freigegeben?
Am Ende eines Blocks oder? Das würde bedeuten, dass die Beispiele schief laufen. Stimmt das?

static int i;//bleibt gültig bis zum Programmende

(und es ist generell keine gute Idee, die Adresse einer lokal definierten Variablen nach außen zu übergeben)

Ja, die Variable wird in dem Moment freigegeben, wo ihr Block verlassen wird - außer du definierst sie als statische Variable:

static int i;//bleibt gültig bis zum Programmende

(und es ist generell keine gute Idee, die Adresse einer lokal definierten Variablen nach außen zu übergeben)

okay, danke!
wie schreibt man dann aber eine funktion die einen String zurückgeben soll?
Sagen wir den festen String "Test"?
Das mit static wäre ja ätzend. Will ja nicht nen haufen Variablenleichen im Keller haben, wenn die Funktion mehrmals aufgerufen wird.

(und um Strings zu übergeben, empfehle ich std::string)

Also:

char *string = "Test"; // "string" sind 4 Byte Zeiger auf dem Stack.
                       // "string" enthält Adr. von konstantem String "Test"
return string;         // Eben jene Adr. wird zurückgegeben und die 4 Byte 
                       // der Variable "string" freigegeben

Oder?!

IMHO sollte das erste Beispiel (char*) sogar korrekt laufen, da hier nicht die Adresse des charpointers auf dem Stack sondern die Adresse des konstanten Strings "Test" (welcher im Data-Segment liegen müsste) zurückgegeben wird.

Also:

char *string = "Test"; // "string" sind 4 Byte Zeiger auf dem Stack.
                       // "string" enthält Adr. von konstantem String "Test"
return string;         // Eben jene Adr. wird zurückgegeben und die 4 Byte 
                       // der Variable "string" freigegeben

Oder?!

ich denke, das genau ist mein problem. ich glaube aber das es nicht funktioniert.

char *string = "Test"

ist ja nur eine Abkürzung für

char string[5];
string[0] = 'T';
string[1] = 'e';
string[2] = 's';
string[3] = 't';
string[4] = 0;

und der bereich wird dann wieder am Ende der Funktion freigegeben, nicht? ein Array muss man ja nicht wieder mit delte freigeben!

Wie gesagt, auf der sicheren Seite bist du wirklich nur mit new (aber dann das delete nicht vergessen) oder std::string:

string stringfunction()
{
  string data="Test";
  return data;//hier werden die Zeichendaten evt. kopiert
}

Nein, das ist nicht das selbe - das Literal wird in dem Fall im Datensegment gelagert und string bekommt die Adresse dieses Bereichs zugewiesen (die Abkürzung für die Initialisierung wäre char "string[]="Test";").

Wie gesagt, auf der sicheren Seite bist du wirklich nur mit new (aber dann das delete nicht vergessen) oder std::string:

string stringfunction()
{
  string data="Test";
  return data;//hier werden die Zeichendaten evt. kopiert
}

okay! also werden normale arrays auf dem stack angelegt?
was meinst du mit "evtl. kopiert"?

was meinst du mit "evtl. kopiert"?

std::string verwaltet die Zeichen auf dem Heap und kümmert sich selber um die new/delete Angelegenheiten. Da hängt es von der Implementierung ab, ob bei "return data;" nur der Zeiger auf die exisiterenden Daten übergeben wird oder ein neuer Bereich mit einer Kopie angelegt wird.

danke, in jedem fall! hast mir weitergeholfen!

na, da muss ich das letztere erhoffen...

Nö, erhoffen musst du gar nichts. Wenn std::string hier nur ein simples return macht, weil es zB mit COW Semantik implementiert ist, dann kann dir das auch egal sein. Das ist ja auch das schöne an solchen Containern. Ihre Funktionalität ist immer gleich, egal wie sie implementiert sind.

char *string = "Test"

Nur so zur Info, diese Konvertierung (von const char[] nach char*) ist veraltet und sollte nicht mehr verwendet werden (reines Kompatibilitätsfeature zu C). Sie wird auch öfters liebevoll als "Conversion of Death" bezeichnet, da ein Zeiger auf ein Literal plötzlich schreibbar gemacht wird. Da das Literal 'ROMable' ist, liegt es wahrscheinlich nicht im Datensegment, sondern wird eher vom Loader in einen schreibgeschützten Bereich geschoben. Im besten Falle stürzt das Programm bei einem Schreibzugriff ab. Falls der Schreibzugriff gelingen sollte, ändert man vielleicht gleich andere Literale mit, da diese überlagert gespeichert werden dürfen.