C - fgets - verständnisproblem

Du gibst in der Funktion "eingabe" einen Pointer auf eine lokale
Variable dieser Funktion zurück. Die liegt auf dem Stack und ist nach
Verlassen der Funktion ungültig.

Entweder das Array "input" als "static" oder aber außerhalb der
Funktion "eingabe" deklarieren.

ich weiss was ihr meint!

jedoch, da das programm funktioniert (zumindest programm nummer 2, in
welchem MAX 255 gross ist, wobei ich nicht verstehe warum programm 1
nicht funktioniert in dem MAX relativ klein 51 ist) kann anscheinend
doch auf die variable auch nach ende des funktionsaufrufes
zurückgegriffen werden!!!

das programm BSP2.: stammt aus dem buch c von a bis z.

ich weiss, dass normalerweise auf eine

fortsetzung:

ich weiss, dass normalerweise auf eine lokale variable nach beendigung
der funktion in welcher sie deklariert wurde nicht mehr zugegriffen
werden kann...

aber hier geht es!!!

warum?

aber erstmals vielen dank

nun mit der GLOBAL deklarierten variable "char input[MAX]" läuft auch
programm BSP1.

dürfte ein komischer zufalle gewesen sein, dass BSP2 auch so richtig
gelaufen ist!!!

komisch

liebe grüße und danke

>Raph

ALLES FALSCH

jetzt hab ichs!!!

in diesem beispiel wurde ein Zeiger als Argument übergeben!
darum muss die variable "char input[MAX]" nicht als STATIC oder
GLOBAL deklariert sein!

Die Funktion eingabe() gibt eben einen solchen Speicherbereich (lokales
Feld) zurück, der sich ebenfalls auf diesem Stack-Frame befindet bzw.
befand – und somit bei Beendigung der Funktion nicht mehr vorhanden
ist. Wollen Sie also einen Zeiger auf einen Speicherbereich
zurückgeben, haben Sie folgende Möglichkeiten. Sie verwenden ...

-einen statischen Puffer (static).
-einen beim Aufruf der Funktion als Argument übergebenen Puffer.
-einen mittels malloc() reservierten Speicher

Bsp.:
Hierzu ein Beispiel, welches alle drei Möglichkeiten demonstrieren
soll:

/* ptr14.c */
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* Fehler: Funktion gibt die Adresse
 * einer lokalen Variablen zurück */
char *test1(void){
   char buffer[10];
   strcpy(buffer, "testwert");
   return buffer;
}
/* Möglichkeit1: Statische Variable */
char *test2(void){
   static char buffer[10];
   strcpy(buffer, "testwert");
   return buffer;
}
/* Möglichkeit2: Speicher vom Heap verwenden */
char *test3(void){
   char *buffer = (char *) malloc(10);
   strcpy(buffer, "testwert");
   return buffer;
}
/* Möglichkeit3: Einen Zeiger als Argument übergeben */
char *test4(char *ptr){
   char buffer[10];
   ptr = buffer;
   strcpy(buffer, "testwert");
   return ptr;
}
int main(void) {
   char *ptr;
   ptr = test1();
   printf("test1: %s\n", ptr); // Datenmüll
   ptr = test2();
   printf("test2: %s\n", ptr);
   ptr = test3();
   printf("test3: %s\n", ptr);
   test4(ptr);
   printf("test4: %s\n", ptr);
   return EXIT_SUCCESS;
}

das war nun die erklärung/lösung meines problems!!!

lg >Raphael

Nein, Du hast es nicht.

Möglichkeit 4 unterscheidet sich inhaltlich nicht von der fehlerhaften
Möglichkeit 1, denn der Puffer, auf den der Pointer verweist, ist nach
wie vor ein lokaler Puffer. Und ist damit ebenso falsch.

Mäßig korrekt sind somit nur 2 und 3, wobei bei 3 nach Aufruf der
Funktion tunlichst der per malloc angeforderte Speicher auch
wiederfreigegeben werden sollte, sonst gibt es Speicherlecks.

> das programm BSP2.: stammt aus dem buch c von a bis z.

Ich hoffe es ist dort als abschreckendes Beispiel gezeigt, das
verdeutlicht das 'undefiniertes Verhalten' (so heist das in
der C-Fachsprache) auch bedeuten kann: "Sieht auf den ersten
Blick so aus als ob es gehen würde, ist aber trotzdem falsch."

hi leute,

ist in der online fassung und in meinem buch gleich! also wenn es
tatsächlich ein fehler ist, dann in allen versionen!

ich hab ja den "fehler" nicht gefunden! den habt ja ihr gefunden :-)

leute ich weiss was undefiniertes verhalten bedeutet... das einzige was
ich nicht kann ist anständig zu programmieren!!! darum arbeite ich ja
hart daran :-)

es war mich auch unklar, aber ich dachte durch

return strtok(variable, "\n"); /* auch wenn sie "nur" in der
aufgerufenen funktion deklariert ist, bleibt der speicher erhalten!
... da jürgen wolf in seinem buch ja auch extra angegeben hatte EINEN
ZEIGER ALS ARGUMENT ÜBERGEBEN .. dachte ich dies ist eine andere
vorgehensweise!

nun gut, ich werde jürgen wolf darauf aufmerksam machen
mal sehn was er dazu sagt...

:-) in zukunft werd ich mit static oder GLOBAL arbeiten!!!

danke leute

>Raphael

ja leute war mein fehler, sehr peinlich

ich dachte er meinte als abschreckendes beispiel folgenden auszug
welcher kurz nach dem eigentlich programm kam

char *eingabe(char *str){
     char input[MAX];

     printf("Bitte \"%s\" eingeben: ", str);
     fgets(input, MAX, stdin);
     return input;
}

tut mir total leid leute
ich hab mir diese zeilen auch gelesen... nur ich dachte er meinte das
folgende

ich tip die listen chronologisch ab, und das buch find ich auch sehr
gut und ausführlich, nur er gibt oft negativbeispiele an... in diesem
fall hab ichs nicht erkannt!!!

sorry leute!!!

bin normal vorsichtig beim posten

das hab ich ja anfangs auch vermutet!!!

aber da anscheinend BSP2 zufällig richtig läuft und BSP1 nicht
denke ich nicht dass strtok() den extrahierten string selber nochmal
als static speichert!

aber ich weiss es nicht...

ich sollt mich mit was leichterem befassen!!!

soweit bin ich wie man merkt noch nicht :-)

> :-) in zukunft werd ich mit static oder GLOBAL arbeiten!!!

Beides sind Varianten, die du nicht machen solltest!

DIe Methode: Einen Zeiger auf die Speicherfläche in die Funktion
hinein zu übergeben, ist die Methode, die du benutzen solltest.

/* Möglichkeit3: Einen Zeiger als Argument übergeben */
char *test4(char *ptr){
   strcpy(ptr, "testwert");
   return ptr;
}

Aber wenn du das schon so machst, dann falle nicht in die
gets() - fgets() Falle hinein:
Frage: Was ist falsch an gets() und wurde mit fgets() behoben?
Antwort: Man hat verabsäumt bei gets() einen weiteren Parameter
mit aufzunehmen, der gets darüber informiert wie gross den nun
der Buffer ist, in den es schreiben darf.

Genau wie bei test4()
test4 hat keine Möglichkeit festzustellen, wie gross den die Speicher-
fläche ist, auf die es einen Pointer bekommen hat. Daher kann test4
sich nicht davor schützen, diesen Buffer zu überlaufen.

Richtig wäre:

/* Möglichkeit3: Einen Zeiger als Argument übergeben */
char *test4(char *ptr, size_t BufferSize){
   if( BufferSize < 9 )
     return NULL;
   strcpy(buffer, "testwert");
   return ptr;
}

Und auf der Aufrufseite folgerichtig:

int main()
{
  char Buffer[4];

  if( test4( Buffer, sizeof( Buffer ) ) == NULL )
    printf( "Fehler: Buffer zu klein. Machen Sie das Array
groesser\n" );
}

@karl heinz buchegger

ok werd ich machen!!!

denn wie heissts so schön:
---> "so LOKAL wie möglich, so GLOBAL wie nötig!!!"

lg und danke

>Raph

... die Liste ließe sich fortsetzen:

strcat / strncat
sprintf / snprintf