Zeichen mit der Konsole einlesen.

Hallo

Uups, da habe ich einen Fehler wiederholt. Entschuldige bitte
C: 
#include <stdio.h>
#include <stdlib.h>
 
int main ()
{
    char* buffer = NULL;
    int get = 0;
	int i = 0;
 
 
    for (i=0; (get=fgetc(stdin))!=EOF; i++)
    {
      buffer = (char*)realloc(buffer, i+1);     //Muss früher sein, da sonst gar kein Speicher bereitsteht
      buffer[i] = get;
    }
 
    char* ausgabe = buffer;
 
    while (i > 0) //ausgabe[0] willst du ja auch noch haben
    {
      printf("%c", ausgabe[i-1]);
      i--;
     
    }
    free(ausgabe); //Das muss raus aus der while-Schlaufe, sonst wird der Speicher ständig freigegeben, und das willst du nicht
	return 0; //Sonst heult dir der Compiler die Ohren voll
}
Ich weiss, ich sollte es selber testen, bin aber gerade zu faul, ein neues Projekt dafür zu erstellen ;-)

Gruss
cwriter

EDIT: Code verbessert
 
Zuletzt bearbeitet:
Jetzt hab ich es verstanden :) Schön wenn es im Kopf klick macht.

Scheint ja hier ein wirklich tolles Forum zu sein, danke an alle******!

Schönen Abend noch :)
 
Wenn das Thema erledigt ist, drücke bitte noch den blau-weissen Haken, um es als solches zu markieren.

Ansonsten wünsche ich dir ebenfalls einen schönen Abend :)

Gruss
cwriter
 
Wenn ich theoretisch noch abfragen möchte ob überhaupt noch genug Speicher da ist. Ginge das dann so? Ist mir gerade noch eingefallen.

Danke :)

C: 
for (i=0; (get=fgetc(stdin))!=EOF; i++)
    {
      buffer = (char*)realloc(buffer, i+1);     //Muss früher sein, da sonst gar kein Speicher bereitsteht
      
      if ( buffer == NULL)
        { 
          printf("Out of memory.\n");
          return 1;
        } 
      
      buffer[i] = get;
      printf("%c", buffer [i]);
      
    }
 
Hi

die Prüfung selbst ist so ok; kann bei malloc auch direkt so eingesetzt werden.
Bei realloc gibt es aber ein kleines "Problem":
Angenommen, es gibt nirgends Fehler,
dann wird der reservierte Speicher ja am Schluss mit free wieder freigegeben.

Wenn zwar die Erstreservierung funktioniert hat, aber dann ein realloc danebengeht,
bedeutet das, dass der Speicher zwar nicht vergrößert wurde, aber:
Der alte unvergrößerte ist noch zum free´n, bevor man das Programm abbricht oÄ.

Ein fehlgeschlagenes realloc erkennt aber aber eben dadurch,
dass es die Variable mit der Adresse mit NULL überschreibt
->man hat die Adresse nicht mehr, die man für free braucht.

Ist etwas "dumm" so (ich hab zwar keine besseren Vorschlag,
wie realloc zu funktionieren hat, aber...naja)
Jedenfalls braucht man wegen diesem Verhalten eine weitere Variable,
die die Adresse noch hat, auch wenn sie in Variable 1 genullt wurde.

Etwa so, folgenden Code durch den Nächsten ersetzen:
C: 
buffer = (char*)realloc(buffer, i+1);
if ( buffer == NULL)
{ 
    printf("Out of memory.\n");
    return 1;
}
C: 
{
    char *buffer2;
    buffer2 = (char*)realloc(buffer, i+1);
    if ( buffer2 == NULL)
    {
        free(buffer);
        printf("Out of memory.\n");
        return 1;
    }
    buffer = buffer2;
}
Die neuen {} um alles herum sind nur, damit die neue Variable buffer2 nach diesem Codeteil
ieder weg ist (und man unabhängig von dem auch andere buffer2 haben kann, wenn man will)
Wenn man irgendeine passende ungebrauchte Variable schon hat
kann man die natürlich auch statt buffer2 verwenden
(und die {} sowie das "char *buffer2;" eben entfernen).
 
Hey,

ich versteh das jetzt nicht mehr so wirklich. Hier mein Code den ich jetzt habe:

C: 
{
  char* buffer = (char *) malloc (MAX * sizeof(char));
  int get = 0;
  int i = 0;
  char* buffer2;
 
   
  for (i=0; (get=fgetc(stdin))!=EOF; i++)
    {
      buffer = (char*)realloc(buffer, i);     //Muss früher sein, da sonst gar kein Speicher bereitsteht
      
      buffer = buffer2;
      buffer2 = (char*)realloc(buffer, i+1);
                
            if ( buffer2 == NULL)
            {
                free(buffer);
                printf("Error:Out of memory.\n");
                return 1;
            }
            
              else {
      buffer[i] = get;
      printf("%c", buffer [i]);
      
      }
    
    }
 
Sollte nun so passen :) oder hab ich was übersehen?

C: 
#include <stdio.h>
#include <stdlib.h>

#define BLOCK_SIZE 128

#define SUCCESS 0
#define ERROR_NO_MEMORY 1

int main()
{
  int char_counter = 1;
  int block_counter = 1;
  
  // first BLOCK_SIZE bytes
  char *buffer = malloc((block_counter*BLOCK_SIZE) * sizeof(char));
  
  if (buffer == NULL)
    return ERROR_NO_MEMORY;
  
  int character;
  int index = 0;
  while ((character = getchar()) != EOF)
  {
    char_counter++;  // always one larger than actual number of chars
                     // because of the 0-Byte
    
    if ((char_counter % BLOCK_SIZE) == 0)
    {
      // BLOCK_SIZE bytes more
      char *temp = realloc(buffer, (++block_counter*BLOCK_SIZE) * sizeof(char));
    
      if (temp == NULL)
      {
        free(buffer);
        buffer = NULL;
        
        return ERROR_NO_MEMORY;
      }
      
      buffer = temp;
    }
    
    buffer[index++] = character;
  }
  
  buffer[index] = '\0';  // don't forget that
  
  printf("%s\n", buffer);
  
  
  char* ausgabe = buffer;
  
   while (char_counter > 0) //ausgabe[0] will man ja auch noch haben
    {
      printf("%c", ausgabe[char_counter-1]);
      char_counter--;
    }
     printf("\n");
  
  
  free(buffer);
  
  return SUCCESS;
  
}
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück