# C: string als Rückgabetyp einer Funktion



## paddymann (19. Dezember 2007)

Moin!
Ich möchte in C  eine Funktion einen String zurückgeben lassen. Hier mal ein (unnützer) Code, bei dem mir klar ist, dass das so nicht funktionieren kann:

```
/*falscher Code*/
#include <stdio.h>
#include <string.h> //dachte, der könnte den Typ "string" definieren...

string function()
{
 char str[] = "abcdefgh";
 return str; //?
}

int main()
{
 printf("%s", function()); //den String ausgeben
 getchar();
 return 0;
}
```

Problem is ja jetzt noch, dass er den Datentyp string gar net kennt. Und was ist da sonst noch falsch? Muss ich das char-Array noch anders definieren; sofort als String auch ?

Vielen Dank!
mfg
.patrick


----------



## deepthroat (19. Dezember 2007)

Hi.





paddymann hat gesagt.:


> Problem is ja jetzt noch, dass er den Datentyp string gar net kennt. Und was ist da sonst noch falsch? Muss ich das char-Array noch anders definieren; sofort als String auch?


In C gibt es keinen *string* Typ. Ein C-String (sprich: String in C) ist lediglich ein Array von Zeichen. D.h. einen C-String kann man wie ein ganz normales Array behandeln.

Man kann keinen Zeiger auf ein lokales Objekt zurückgeben (so wie du es in deinem Code versucht hast).

Man könnte aber ein statisches Feld definieren, dessen Adresse aus der Funktion zurückgegeben wird (so wie bei den Funktionen ctime, asctime):
	
	
	



```
const char* func() {
  static char* str = "asdf";

  return str;
}
```
Das hat allerdings den Nachteil, das jeder Aufruf der Funktion die Variable überschreiben könnte. Genau dasselbe gilt für eine globale Variable.

Am besten schreibt man eine Funktion die einen C-String zurückgibt, nach dem Vorbild der vorhandenen String-Funktionen (strcpy, strdup etc.), die zur Rückgabe einen Parameter verwenden und im Fehlerfall NULL zurückgeben:
	
	
	



```
char* func(char* out, int len) {
  // out ist ein "Ausgabeparameter"
  
  // out verändern...

  if (<Fehler>) return NULL;
  else return out;
}

// Verwendung:

char x[50];

if (func(x, 50) != NULL) {
  puts(x);
}
```
Man kann natürlich auch einen neu allozierten C-String zurückgeben, allerdings ist dann der Aufrufer dafür verantwortlich den String wieder freizugeben:
	
	
	



```
char* func() {
  char* str = malloc(50);

  // ...

  return str;
}

// Verwendung:
char* x = func();

if (x != NULL) {
  puts(x);

  free(x);
}
```
Gruß


----------



## Thomasio (20. Dezember 2007)

... oder man spart sich den ganzen Aufstand und verwendet std::string


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

std::string function()
{
 std::string str = "abcdefgh";
 return str;
}

int main()
{
 printf("%s", function().c_str());
 getchar();
 return 0;
}
```


----------



## deepthroat (20. Dezember 2007)

Thomasio hat gesagt.:


> ... oder man spart sich den ganzen Aufstand und verwendet std::string


Es geht um C.

Gruß


----------



## paddymann (20. Dezember 2007)

Danke für die Antowrten.
Jo wollte das mit C machen und nicht mit C++ und .c_str() aus der STL. Mit den von deepthroat aufgezeigten Möglichkeiten komm ich klar. Danke dafür!

mfg
.patrick


----------

