DIesmal hab ich folgendes Problem:

char *test1(void){
   char buffer[10];
   strcpy(buffer, "testwert");
   return buffer;
}

wieso gibt

char *ptr;

 ptr = test1();

wieso bekommt die referenz vom zeiger ptr dann nicht den Wert testwert ??
wenn ich in der test1 funktion char buffer [10]; als static deklariere läuft es jedoch... wieso das??

thx & mfg!!

char *test1(void){
   char *buffer = new char[10];
   strcpy(buffer, "testwert");
   return buffer;
}	

char *ptr = test1();	
...
// am schluss immer schön den speicher freigeben...
delete [] ptr;

cu

mach mal:
...

Dann begreife, was es tut ..... und mach es nie wieder !
(bei einer solchen Situation ist es kaum zu vermeiden, dass man hier/da ein delete[] vergisst oder das falsche delete verwendet....)
Zum Lernen ist das natürlich gut und erlaubt, aber es zeigt eben auch, welche Probleme man mit Zeigern als Rückgabewert hat: Man weiß nicht, wem sie "gehören" (sprich: Wer dafür sorgen muss, Speicher wieder freizugeben), noch "was sie sind" (vielleicht nur die Adresse eines Speicherstücks auf dem Stack ? Oder auf ein Stringliteral ? Oder etwas Anderes, worauf man kein delete machen darf ?)...

Gruß,

Simon2.

#include <string>

std::string test()
{
    std::string ret = "Testwert"; // ...
    return ret;
}

// ...
std::string foo = test();

eine allgemeine frage zu den rückgabewerten per zeiger,
unter welcher form wird der zeiger zurückgeliefert?

int* foo(int value)
    {
      int arr[2];
      arr[0]=value;
      arr[1]=-value;
      return arr;
    }

ist der rückgabe wert &arr, oder arr??
in diesem fall würde ich sagen arr, weils halt ein array ist oder?

PS:
Vielen dank für die lösungen leute, aber die sind nicht das problem, die hab ich schon, das prob. is halt nur dass ich nich verstand weshalb die funktion falsche werte zurückliefert, tritzdem thx

thx & mfg!!

thx & mfg!

Weil lokale Variablen am Ende der Funktion zerstört werden. Statische Variablen hingegen überdauern die gesamte Laufzeit des Programms.

Das ist die Antwort!! Nach dem return (Ende der Funktion) ist arr nicht mehr gültig und du verweist auf einen Speicherbereich der freigegeben ist.

Ob du &arr oder arr schreibst ist egal, beides das selbe.

LordJaxom schrieb:

Ob du &arr oder arr schreibst ist egal, beides das selbe.

nein, &arr ist ein Zeiger auf ein Array und arr ein Zeiger auf das erste Element des Arrays. Also ist es egal ob du arr oder &arr[0] schreibst.

die funktion liefert ja eigentlich die adresse zurück wieso lautet die funktions deklaration dann nich, oder bedeutet der dereferenzierungsoperator nur, dass der rückgabewert nur und nur an einen pointer (von mir aus in der main() funkt. definiert) übergeben werden kann. die funktion aber selbst eben keinen pointer übergibt, sondern den wert an einen pointer.

thx & mfg!!!

also die funktion gibt seinen wert nur an einen pointer weiter, das bedeutet ja auch dass sie die adresse zurückliefert denn *ptr1 = *ptr2 geht ja nich, da wir jetzt davon ausgehen, dass ptr1 nicht definiert wurde. ptr2 stellt hier den rückgabewert vor. damit es läuft, kann der rück.wert dann nur die adresse sein, wie ich vorhin schon sagte also &ptr2 oder ptr2.

also müsste man doch dann eigentlich sagene, die funktion würde eine adresse zurückliefern jund keinen pointer sonder die adresse an einen pointer.

thx & mfg!!

Zeiger sind im Prinzip nichts anderes als ganz normale Variablen, die statt Datenobjekten wie Zahlen, Zeichen oder Strukturen eben Adressen eines bestimmten Speicherbereichs beinhalten.

ausschnitt aus dem buch c von a bis z,
bei www.galileocomputing.de gibts das teil umsonst (als e-book)!!
ist die sonstige interpretation von mir richtig oder nich?

thx & mfg!!

das ist ja so richtig oder?

thx &mfg!!!

int* getAdress( int value )
{
    return &value;
}
int* pointer;
pointer = getValue( 17 );

Oder du gibst die Zahl zurück und weist sie dem Pointer zu

int getValue( int value )
{
    return value;
}
int* pointer;
*pointer = getValue( 17 );
//oder
pointer = &getValue( 42 );

Bitte nicht nach dem Sinn des Beispiels fragen

Aber das hier:

int* foo(int value)
    {
      int arr[2];
      arr[0]=value;
      arr[1]=-value;
      return arr;
    }

Gibt dir gar nichts, weil arr beim Verlassen des Funktionsblocks zerstört wird.