char* als Rückgabewert einer Funktion

Fishmac

Hallo Leute,

hab nochmal ne Frage - auch auf die Gefahr hin, dass es hier schon mal behandelt wurde - ich finds aber nicht

Also, folgendes:

... main(...){
  char * result;

  result=function();

  printf("%s\n",result);
}

char* function(void){
 char* tmp = "Nix";
 ...

 return nix;
}

Wo liegt der Fehler, wenn ich bei der Ausgabe nur wirre Zeichen bekomme bzw. wie kann man es besser machen?

Vielen Dank
Fishmac

proggingmania

Hi !

Wenn der Block deiner function(void) verlassen wird, existiert die lokal angelegte Variable tmp nicht mehr.

Du kannst ein Array als Parameter übergeben und "Nix" z.B. mit strcpy reinkopieren.
Oder du kannst lokal mit malloc eine Zeichenkette auf dem Heap erzeugen und den Zeiger zurückgeben.

Fishmac

Äh natürlich meinte ich

return tmp;

SORRY

this-*gt*that

Übergib wie gesagt einfach den Zeiger an die Funktion. Denn wenn du mit malloc alloziierten Speicher zurückgibst, delegierst du das Löschen an den Aufrufer und das ist nicht schön.

proggingmania

Fishmac schrieb:

Äh natürlich meinte ich
return tmp;
SORRY

Ja, tmp ist dann schon gestorben, futsch, gibts nicht mehr.
Darum gibts nur virre Zeichen.

Fishmac

Also sowas hier ?:

main(...){
 char* test = malloc(...sizefo(char));

 test=fnc(test);
 printf("%s\n",test);

 free(test);
}

char* fnc(char* tmp){
 tmp="Nix";

 return tmp;
}

Danke

pale dog

Fishmac schrieb:

Hallo Leute,

hab nochmal ne Frage - auch auf die Gefahr hin, dass es hier schon mal behandelt wurde - ich finds aber nicht

Also, folgendes:
... main(...){
  char * result;

  result=function();

  printf("%s\n",result);
}

char* function(void){
 char* tmp = "Nix";
 ...

 return nix;
}
Wo liegt der Fehler, wenn ich bei der Ausgabe nur wirre Zeichen bekomme bzw. wie kann man es besser machen?

Vielen Dank
Fishmac

so sollte es gehen:

#include <stdio.h>

char* function(void)
{
 char* tmp = "Nix";
 return tmp;
}
int main()
{
  char * result;
  result=function();
  printf("%s\n",result);
}

proggingmania

Nee so geht das nicht.

proggingmania

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

 char* MkStr( char* p )
 {
	char* pret = malloc( strlen(p) + 1 );
	strcpy( pret, p );
	return pret;
 }

 int main()
 {
	 char* pstr = MkStr("Hello World !");

	 puts(pstr);
	 free( pstr );

	 return 0;
 }

pale dog

proggingmania schrieb:

Nee so geht das nicht.

doch, geht, probier's aus.
du brauchst kein 'malloc', der string ist 'fest' und bleibt erhalten...

Minimee

Oder so (wenn auch unschön ):

Fishmac schrieb:

... main(...){
  char * result;

  result=function();

  printf("%s\n",result);
}

char* function(void){
 static char* tmp = "Nix";
 ...

 return tmp;
}

pale dog

Minimee schrieb:

Oder so (wenn auch unschön ):

Fishmac schrieb:

... main(...){
  char * result;

  result=function();

  printf("%s\n",result);
}

char* function(void){
 static char* tmp = "Nix";
 ...

 return tmp;
}

was bezweckst du mit dem 'static'?
möchtest du rechenzeit sparen, weil der pointer 'tmp' bereits vor eintritt in die funktion initialisiert wird?
auf das "Nix" hat es jedenfalls keinen einfluss...

proggingmania

pale dog schrieb:

doch, geht, probier's aus.
du brauchst kein 'malloc', der string ist 'fest' und bleibt erhalten...

Wie war das mit dem Stack und dem Verlassen einer Funktion ?
Ich dachte immer, dann wird der Stack wieder abgeräumt, beim Verlassen der Funktion.

pale dog

proggingmania schrieb:

Wie war das mit dem Stack und dem Verlassen einer Funktion ?
Ich dachte immer, dann wird der Stack wieder abgeräumt, beim Verlassen der Funktion.

stimmt ja auch, aber..
1. der inhalt der stackvariablen wird ja zurückgegeben, d.h. zum aufrufer kopiert, danach kann die variable gelöscht werden, das macht nichts.
2. der string "Nix" wird nicht auf dem stack angelegt, sondern ist konstant und während der gesamten laufzeit vorhanden.

proggingmania

Das ist purer Zufall, das dein String noch lebt, weil der Speicher ungenutzt ist.
Der könnte im weiteren Programmverlauf wieder überschrieben werden.

pale dog

proggingmania schrieb:

Das ist purer Zufall, das dein String noch lebt, weil der Speicher ungenutzt ist.
Der könnte im weiteren Programmverlauf wieder überschrieben werden.

nein, schau mal

#include <stdio.h>

char *hello (void)
{
    return "Hello, World!";  // der string ist konstant, er wird nicht auf dem stack abgelegt, es wird die adresse des strings zurückgegeben.
}
int main()
{
    printf (hello()); // geht, kein problem ;)
}

proggingmania

pale dog schrieb:

1. der inhalt der stackvariablen wird ja zurückgegeben, d.h. zum aufrufer kopiert, danach kann die variable gelöscht werden, das macht nichts.
2. der string "Nix" wird nicht auf dem stack angelegt, sondern ist konstant und während der gesamten laufzeit vorhanden.

Achsooooo !!!
Wieder etwas dazugelernt !!!
Danke !!!

Hi !

Hab in ein C-Buch reingeguckt, die Zeiger müssen als static angelegt
werden. Ansonsten ist der Rückgabewert undefiniert.

Gruß,
p. ( logged off )

rüdiger

Der im C Buch liest. schrieb:

Hab in ein C-Buch reingeguckt, die Zeiger müssen als static angelegt
werden. Ansonsten ist der Rückgabewert undefiniert.

Ne ne ne, lies das was pale dog gesagt hat. Entweder erzählt dein C-Buch Blödsinn oder du hast die Situation verwechselt.

int *FALSCH0() {
  int i = 10; // i liegt auf dem Stack
  return &i; // Fehler: Zeiger auf eine lokale Variable zurück gegeben
} // i existiert nicht mehr, der Zeiger ist ungültig

char *kein_problem() {
  char *foo = "ba";
  return foo;
} // foo existiert zwar nicht mehr, aber das worauf es gezeigt hat

char **FALSCH1() {
  char *foo ="bar";
  char **bar = &foo; // Zeiger auf foo, was auf dem Stack liegt
  return bar;
} // bar, foo existieren nicht mehr. Zeiger ist ungültig

krass