Dateizugriff c/c++

[frank(SMSii) (Gast)]

Hallo zusammen,


da das Thema Dateizugriff oft diskutiert wird, hoffe ich trotzdem auf 
ein paar Antworten.

Ich habe eine Datei, mit folgendem Inhalt:

221 253 028 060 092 123 155 186 218 249 025 056 088 119 151 182 214 246 
021 053 084 116 147 179 210 242 017 049 081 112 144 175 207 238 014 045 
077 108 140 171 203 235 010 042 073 105 136 168 199 231 006 038 069 101 
133 164 196 227 003 034 066 097 129 160 192 223 255 031 062 094 125 157 
188 220 251 027 058 090 121 153 185 216 248 023 055 086 118 149 181 212 
244 019 051 083 114 146 177 209 240 016 047 079 110 142 173 205 237 012 
044 075 107 138 170 201

Nun versuche ich Daten mittels fscanf(...); einzulesen, dazu folgender 
Programmcode:

int hunderter, zehner, einer, summe;

FILE *dateiZeiger;
dateiZeiger = fopen ("datei.txt", "r");


if (dateiZeiger == NULL){
  Finish(); //beendet Programm
}
else{
  while(dateiZeiger){
    fscanf(dateiZeiger, "%d %d %d", &hunderter &zehner &einer);
    summe=hunderter*100+zehner*10+einer;
    cout << summe << endl;
  }
}

Das Programm funktioniert leider nicht! Woran liegt es? Was ist der 
Trick um Zahlen nebeneinander einzulesen!?

Dann versteh ich nicht ganz wie die fscanf(); Funktion funktioniert, 
bzw. wird der Zeiger(dateiZeiger) automatisch erhöht? Gibt es einen 
Fehler wenn die lücke zwischen den Zahlen erreicht ist?


Greetings Frank

[Karl H. (kbuchegg)]

frank(SMSii) schrieb:


>   while(dateiZeiger){
>     fscanf(dateiZeiger, "%d %d %d", &hunderter &zehner &einer);
>     summe=hunderter*100+zehner*10+einer;

Das würde dir bei dieser Datei

 221 253 028 060 092 123 155 186 218 249 025 056 088 119 151 182 214 246

die 221 nach hunderter, die 253 nach zehner und die 28 nach einer 
einlesen. Bist du sicher das du das willst? Deine Variablennamen deuten 
eigentlich auf etwas ganz anderes hin.

> Dann versteh ich nicht ganz wie die fscanf(); Funktion funktioniert,
> bzw. wird der Zeiger(dateiZeiger) automatisch erhöht?

Ja.

> Gibt es einen
> Fehler wenn die lücke zwischen den Zahlen erreicht ist?

das regelt alles der Formatstring

Vielleicht wäre ein Blick in ein Grundlagenbuch wirklich nicht soooo 
verkehrt.

Deine while Schleife rundeherum ist auch verkehrt.
Nein, ein Blick in ein Grundlagenbuch wäre wirklich nicht verkehrt.

[Stefan B. (stefan)]

Dein Formatstring ("%d %d %d") passt nicht auf das Eingabeformat. Bei 
dem ersten Aufruf von fscanf() werden bereits 221 253 028 eingelesen. 
Und wie folgt zugewiesen

hunderter = 221
zehner = 253
einer = 28

Du könntest eine dreistellige Zahl nach der anderen lesen und die 
Variablen dann per Programm füllen.

  while(dateiZeiger){
    fscanf(dateiZeiger, "%d", &summe);
    hunderter = summe / 100;
    zehner = (summe / 10) % 10;
    einer = summe % 10;
    summe = hunderter*100 + zehner*10 + einer;
    cout << summe << endl;
  }

[Ingo (Gast)]

Mit einem "%d" als Formatstring liest die fprintf-Funktion eine 
komplette Dezimalzahl aus der Datei bis zum nächsten Trennzeichen 
(Leerzeichen oder NewLine), ob die einstellig, wie bei dir dreistellig, 
oder neunstellig ist, was Du da drumrumgebaut hast, mit der Addition der 
Dezimalstellen ist nämlich schon drin.
mfG ingo

[frank(SMSii) (Gast)]

Hallo Karl,

> Vielleicht wäre ein Blick in ein Grundlagenbuch wirklich nicht soooo
> verkehrt.

mein Problem ist, ich habe hier ein Grundlagenbuch vom RRZN(Regionales 
Rechenzentrum Niedersachsen). Da steht aber nur wenig drüber drin, 
deshalb frage ich.

>
> Deine while Schleife rundeherum ist auch verkehrt.
> Nein, ein Blick in ein Grundlagenbuch wäre wirklich nicht verkehrt.
>

Danke für die Info, dann weiß ich bescheid.

Tschö

[frank(SMSii) (Gast)]

Okay,

nochmal eine Frage.

Was mache ich, wenn ich nicht weiß wieviele Zahlen ich in der Datei 
habe?
Wäre es möglich Dateien die gerade beschrieben werden, auch gleich 
wieder auszulesen (echtzeit?) ?

Beste Grüße

[Karl H. (kbuchegg)]

frank(SMSii) schrieb:
> Hallo Karl,
>
>> Vielleicht wäre ein Blick in ein Grundlagenbuch wirklich nicht soooo
>> verkehrt.
>
> mein Problem ist, ich habe hier ein Grundlagenbuch vom RRZN(Regionales
> Rechenzentrum Niedersachsen). Da steht aber nur wenig drüber drin,
> deshalb frage ich.

fscanf funktioniert genau gleich wie scanf.
Nur dass es von einer Datei liest und nicht von der Eingabekonsole.

Aber die Bedeutung der Zeichen im Formatstring ist völlig identisch zum 
scanf Fall. Wer mit scanf umgehen kann, kann auch mit fscanf (und 
sscanf) umgehen.

Aber abgesehen davon.
Da du ja die C++ Konsolne Stream Ausgabe über cout benutzt und 
wahrscheinlich auch die Stream-Eingabe über cin: Warum benutzt du dann 
nicht die C++ Streams?
Auch hier wieder: Innerhalb dieser Familie an Funktionalitäten ist alles 
identisch, lediglich das Stream Objekt ist ein anderes. In dem einen 
Fall ist es ein (bereits vorhandenes) Objekt cin, im anderen Fall muss 
man sich ein ein File Stream Objekt selber erzeugen. Das ist aber keine 
Hexerei.

Und ehrlich: Wenn dein Skript da nicht näher darauf eingeht, dann wirf 
es weg. File Handling ist ein wichtiges Thema und jedes C oder C++ Buch 
hat ein umfangreiches Kapitel darüber. Greif im Bücherregal zu den 
Klassikern und nicht zu irgendwelchen esoterischen Machwerken, bei denen 
der Autor in vielen Fällen selbst nicht wusste, worüber er da eigentlich 
schreibt.

[Karl H. (kbuchegg)]

frank(SMSii) schrieb:

> Was mache ich, wenn ich nicht weiß wieviele Zahlen ich in der Datei
> habe?

'Was mache ich'
in welcher Hinsicht?

Musst du die Zahlen irgendwo speichern? Oder was ist dein Problem.

Zum Thema: woher weiß ich, das die Datei zu Ende ist:
Jede Einlesefunktion hat einen Returnwert, der unmittelbar darüber 
Auskunft gibt, ob das Einlesen geklappt hat oder nicht. Wenn da ein 
Fehler auftritt UND danach eine Abfrage des EOF Status der Datei ein eof 
(End of File) ergibt, dann wurde die Datei vollständig gelesen.

> Wäre es möglich Dateien die gerade beschrieben werden, auch gleich
> wieder auszulesen (echtzeit?) ?

Wozu?
Du weißt ja was du geschrieben hast.

Aber um die Frage zu beantworten: Ja, das ist möglich. Man muss die 
Datei read/write eröffnen und dann mittels (f)tell() und (f)seek() 
ständig hin und her 'springen'.

[frank(SMSii) (Gast)]

Karl heinz Buchegger schrieb:
> Greif im Bücherregal zu den
> Klassikern und nicht zu irgendwelchen esoterischen Machwerken, bei denen
> der Autor in vielen Fällen selbst nicht wusste, worüber er da eigentlich
> schreibt.

Irgendwelche Empfehlungen?

[Karl H. (kbuchegg)]

frank(SMSii) schrieb:
> Karl heinz Buchegger schrieb:
>> Greif im Bücherregal zu den
>> Klassikern und nicht zu irgendwelchen esoterischen Machwerken, bei denen
>> der Autor in vielen Fällen selbst nicht wusste, worüber er da eigentlich
>> schreibt.
>
> Irgendwelche Empfehlungen?

C:     Kernighan & Ritchie  'Programmieren in C'

C++:   Stroustroup 'The C++ Programming Language' (gibts
       wahrscheinlich auch auf Deutsch


Wenn dann schon ein kleiner Grundstock an C++ Praxis vorhanden ist:

Scott Meyers    "Effective C++"
Scott Meyers    "More Effective C++"

Meyers hängt aber davon ab, dass du den Stroustroup schon durch hast. 
Ohne das Grundlagenwissen aus dem Stroustroup ist der Meyers sinnlos, 
weil du nicht verstehst, wovon er da eigentlich spricht und warum die 
'Problemkreise' die Meyers anspricht, überhaupt Probleme sind, die 
gelöst werden müssen.

[Klaus W. (mfgkw)]

frank(SMSii) schrieb:
> Was mache ich, wenn ich nicht weiß wieviele Zahlen ich in der Datei
> habe?

Den Rückgabewert von (f)scanf beachten.

[Vlad T. (vlad_tepesch)]

frank(SMSii) schrieb:
> Ich habe eine Datei, mit folgendem Inhalt:
>
> 221 253 028 060 092 123 155 186 218 249 025 056 088 119 151 182 214 246
> 021 053 084 116 147 179 210 242 017 049 081 112 144 175 207 238 014 045
> 077 108 140 171 203 235 010 042 073 105 136 168 199 231 006 038 069 101
> 133 164 196 227 003 034 066 097 129 160 192 223 255 031 062 094 125 157
> 188 220 251 027 058 090 121 153 185 216 248 023 055 086 118 149 181 212
> 244 019 051 083 114 146 17

Ich vermute mal du, must hier auch aufpassen, dass die Parser die Zahlen 
mit einer 0 am Anfang nicht als Oktalzahl interpretieren.

Also vorher lieber zweimal alle ' 0' durch '  ' ersetzen.

[Karl H. (kbuchegg)]

Vlad Tepesch schrieb:
> frank(SMSii) schrieb:
>> Ich habe eine Datei, mit folgendem Inhalt:
>>
>> 221 253 028 060 092 123 155 186 218 249 025 056 088 119 151 182 214 246
>> 021 053 084 116 147 179 210 242 017 049 081 112 144 175 207 238 014 045
>> 077 108 140 171 203 235 010 042 073 105 136 168 199 231 006 038 069 101
>> 133 164 196 227 003 034 066 097 129 160 192 223 255 031 062 094 125 157
>> 188 220 251 027 058 090 121 153 185 216 248 023 055 086 118 149 181 212
>> 244 019 051 083 114 146 17
>
> Ich vermute mal du, must hier auch aufpassen, dass die Parser die Zahlen
> mit einer 0 am Anfang nicht als Oktalzahl interpretieren.

Nope:
Die Regel, dass eine Zahl mit einer führenden 0 eine Oktalzahl ist, gilt 
nur innerhalb des C Source Codes.
Stream lesen ist davon nicht betroffen.

[Random .. (thorstendb)]

wenn du eh nur zahlen einlesen willst, mach fwrite / fread und binary 
file. Ist wesentlich schneller.

[Klaus W. (mfgkw)]

Aber nicht bei der oben vorgegebenen Datei.

[Vlad T. (vlad_tepesch)]

Karl heinz Buchegger schrieb:
> Nope:
> Die Regel, dass eine Zahl mit einer führenden 0 eine Oktalzahl ist, gilt
> nur innerhalb des C Source Codes.
> Stream lesen ist davon nicht betroffen.

Ok, da war ich mir nicht sicher.

[Karl H. (kbuchegg)]

Vlad Tepesch schrieb:
> Karl heinz Buchegger schrieb:
>> Nope:
>> Die Regel, dass eine Zahl mit einer führenden 0 eine Oktalzahl ist, gilt
>> nur innerhalb des C Source Codes.
>> Stream lesen ist davon nicht betroffen.
>
> Ok, da war ich mir nicht sicher.

Hatte früher auch so meine Probleme damit :-)
Aber wenn man einmal darüber nachdenkt, ist auch klar, dass man das auf 
keinen Fall machen darf. Dein Benutzer hätte seine liebe Not damit, wenn 
er bei einer Zahleneingabe führende 0-en eingibt. Das dann eigenmächtig 
als Oktalzahl zu interpretieren, wäre höchst kontraproduktiv von den 
Einlesefunktionen.

[frank(SMSii) (Gast)]

Hallo nochmal,


das mit dem Datei einlesen funktioniert jetzt. Dafür möchte ich ein 
ähnliches Problem angehen.

Dazu verwende ich eine µC der Daten an die Serielle Schnittstelle 
sendet, dabei handelt es sich immer noch um das schon oben beschriebene 
Zahlenformat(hterm):

221 253 028 060 092 123 155 186 218 249 025 056 088 119 151 182 214 246
021 053 084 116 147 179 210 242 017 049 081 112 144 175 207 238 014 045

Nun möchte ich die Zahlen aber nicht erst umständlich in eine Datei 
Speichern, sondern gleich im Programm verwerten.

Zum öffnen des COM1-Ports und einlesen der Werte benutze ich folgenden 
Quelltext (ziemlich lang):

#include <stdio.h>
#include <windows.h>
#include <conio.h>
#include <stdlib.h>

#ifndef com_h_INCLUDED
#define com_h_INCLUDED


DWORD dwWritten;

DCB dcb;
COMMTIMEOUTS commtimeouts;

DWORD commerr;
COMSTAT comstat;
DWORD bytes_read;

// Definition der seriellen Schnittstelle
// mehr Informationen siehe:: http://msdn.microsoft.com/de-de/library/aa363858(v=VS.85).aspx

#define lpFileName              "Com1"                     
 // Namen der zu öffnenden Schnittstelle angeben
#define dwDesiredAccess         GENERIC_READ                
 // was soll am COMx-Port ausgeführt werden? _WRITE _READ (ODER-Verknüpft)
#define dwShareMode             0                          
 // schließt den COMx-PORT für andere Programme!!
#define lpSecurityAttributes    NULL                       
 // Standard Sicherheits Beschreibung (NULL = Standard)
#define dwCreationDisposition   OPEN_EXISTING              
 // Gerät muss angeschlossen sein --> sonst Fehleraufruf: ERROR_FILE_NOT_FOUND
#define dwFlagsAndAttributes    FILE_ATTRIBUTE_NORMAL      
 // Datei bekommt keine zusätzlichen Attribute
#define hTemplateFile           NULL                       
 // definiert eine Template-Datei (NULL = Standard)


int com_geti(int *com_inputi, HANDLE hComm);
void ini_com(float baudrate, HANDLE *pComm);

int main(int argc, char* argv[]){
    
    //Serielle Schnittstelle öffnen
    HANDLE hComm = CreateFile(
      lpFileName,
      dwDesiredAccess,
      dwShareMode,
      lpSecurityAttributes,
      dwCreationDisposition,
      dwFlagsAndAttributes,
      hTemplateFile
    );           
    ini_com(115200, &hComm);  
    
    FILE *fdatei = fopen("Datei.txt", "w");
   
    int com_inputi;   
    while(1) {
        
        if( com_geti(&com_inputi, hComm) == TRUE) {   //Serielle Schnittstelle nach neuen Zeichen abfragen
            printf("%d \n", com_inputi);               //das Empfangene Zeichen in der Konsole ausgeben
            fprintf( fdatei, "%d ", com_inputi);       //das Empfangene Zeichen in die Datei schreiben
        }
    }
    
    return 0;  
}


int com_geti(int *com_inputi, HANDLE hComm) {

  ClearCommError(hComm, &commerr, &comstat);
  if(comstat.cbInQue != 0 && ReadFile(hComm, com_inputi, 1, &bytes_read, NULL) != 0) 
    return TRUE;
  else 
    return FALSE;
}


void ini_com(float baudrate, HANDLE *pComm) {
   // Port geöffnet?
   if(pComm == INVALID_HANDLE_VALUE)
   { 
        MessageBox(NULL,"COM Port schon geöffnet.\nSchließen Sie alle Programme die auf den COM Port zugreifen.","Fehler!",
         MB_ICONEXCLAMATION | MB_SETFOREGROUND | MB_OK); 
        exit(0);
   }
   // IO-Buffer setzen
   if(SetupComm(*pComm, 2048, 2048) == FALSE) 
   { 
        MessageBox(NULL,"COM Port konnte nicht erstellt werden.\nPrüfen Sie ob der COM Port im Gerätemanager vorhanden ist.",
         "Fehler!", MB_ICONEXCLAMATION | MB_SETFOREGROUND | MB_OK); 
        exit(0);
   }
   // COM-Port einstellen
   if(GetCommState(*pComm, &dcb) == FALSE)
   { 
        MessageBox(NULL,"COM Port konnte nicht Eingestellt werden","Fehler!", MB_ICONEXCLAMATION | MB_SETFOREGROUND | MB_OK); 
        exit(0);
    }
    
   dcb.BaudRate = 115200;//(DWORD)baudrate;          // current baud rate
   dcb.fParity = FALSE;                     // enable parity checking
   dcb.fOutxCtsFlow = FALSE;                // Bestimmt, ob der Ausgabehandshake, der das CTS (Clear To Send)-Signal verwendet, ein- oder ausgeschaltet ist.
   dcb.fOutxDsrFlow = FALSE;                // Bestimmt, ob der Ausgabehandshake, der das DSR (Data Set Ready)-Signal verwendet, ein- oder ausgeschaltet ist.
   dcb.fDtrControl = DTR_CONTROL_ENABLE;    // Bestimmt, ob das DTR (Data Terminal Ready)-Signal ein, aus oder auf Handshake (hs) bzw. umschaltbar (tg) ist.
   dcb.fDsrSensitivity = FALSE;             // DSR sensitivity
   dcb.fTXContinueOnXoff = FALSE;           // XOFF continues Tx
   dcb.fOutX = FALSE;                       // XON/XOFF out flow control
   dcb.fInX = FALSE;                        // XON/XOFF in flow control
   dcb.fErrorChar = FALSE;                  // enable error replacement
   dcb.fNull = FALSE;                       // enable null stripping
   dcb.fRtsControl = RTS_CONTROL_ENABLE;    // RTS flow control
   dcb.fAbortOnError = FALSE;               // abort reads/writes on error
   // dcb.fDummy2 = fDummy2;                // reserved
   // dcb.wReserved = wReserved;            // not currently used
   dcb.XonLim = 0;                          // transmit XON threshold
   dcb.XoffLim = 0;                         // transmit XOFF threshold
   dcb.ByteSize = 8;                        // number of bits/byte, 4-8         /***  8-N-1  ***/
   dcb.Parity = 0;//NOPARITY;                   // 0-4=no,odd,even,mark,space
   dcb.StopBits = 1;//ONESTOPBIT;               // value 0,1,2 = 1, 1.5, 2 stop bits
   dcb.XonChar = 0;                         // Tx and Rx XON character
   dcb.XoffChar = 0;                        // Tx and Rx XOFF character
   dcb.ErrorChar = 0;                       // error replacement character
   dcb.EofChar = 0;                         // end of input character
   dcb.EvtChar = 0;                         // received event character 
   dcb.fBinary = TRUE;                      // binary mode, no EOF check
   
   //if(SetCommState(*pComm, &dcb) == FALSE) Fehlerausgabe(1);
   
   memset(&commtimeouts, 0, sizeof(COMMTIMEOUTS));                                  // Timout setzen
   //if(SetCommTimeouts(*pComm, &commtimeouts) == FALSE) Fehlerausgabe(2);   
   dcb.fBinary = TRUE;                                                              // binary mode, no EOF check   
   PurgeComm(pComm, PURGE_RXABORT | PURGE_TXABORT | PURGE_RXCLEAR | PURGE_TXCLEAR); // IO-Buffer leeren
}
#endif

Das nun auftretende Problem ist das Zahlenformat, welches ich erhalte 
und das sieht folgendermaßen aus:

4199534 4199469 4199527 4199502 4199543 4199535 4199543 4199535 4199527 
4199502 4199543 4199535 4199541 4199535 4199463 4199534 4199543 4199503 
4199527 4199531 4199541 4199502 4199461 4199502 4199506 4199426 4199463 
4199503 4199426 4199506 4199490 4199504 4199541 4199498 4199490 4199501 
4199527 4199534 4199543 4199531 4199527 4199498 4199477 4199499 4199461 
4199530 4199525 4199498 4199442 4199525 4199502 4199525 4199498 4199442

Die Kennzahlen für die Übertragung lauten:

BAUD: 115200
Bitanzahl: 8
Parity: None
Stopbits: 1

also 8N1.

Kann mir jemand sagen ob er/sie das Problem sieht?

Beste Grüße
Frank

[Läubi .. (laeubi)]

frank(SMSii) schrieb:
> Quelltext (ziemlich lang):
Wichtige Regeln - erst lesen, dann posten!
•Längeren Sourcecode nicht im Text einfügen, sondern als Dateianhang

> Kann mir jemand sagen ob er/sie das Problem sieht?
Deine Daten vom uC sind vermutlich garnicht als ASCII codiert wie du es 
ursprünglich behauptet hast...

[Karl H. (kbuchegg)]

Läubi .. schrieb:

>> Kann mir jemand sagen ob er/sie das Problem sieht?
> Deine Daten vom uC sind vermutlich garnicht als ASCII codiert wie du es
> ursprünglich behauptet hast...

Könnte aber doch sein.
Das Problem könnte sein, dass er hier

        if( com_geti(&com_inputi, hComm) == TRUE) {   //Serielle Schnittstelle nach neuen Zeichen abfragen
            printf("%d \n", com_inputi);               //das Empfangene Zeichen in der Konsole ausgeben
            fprintf( fdatei, "%d ", com_inputi);       //das Empfangene Zeichen in die Datei schreiben
        }

nicht das Zeichen, sondern den ASCII Code des Zeichens ausgibt.

Mir scheint, dem TO ist noch gar nicht klar, dass das hier

"089"

erst mal nur ein String, bestehend aus Zeichen ist und keine Zahl. Eine 
Sequenz von Zeichen wird aber nicht magisch zu einer Zahl, sondern man 
muss etwas dafür tun.

Ändere erst mal so um

        if( com_geti(&com_inputi, hComm) == TRUE) {   //Serielle Schnittstelle nach neuen Zeichen abfragen
            printf("%c \n", com_inputi);               //das Empfangene Zeichen in der Konsole ausgeben
            fprintf( fdatei, "%c ", com_inputi);       //das Empfangene Zeichen in die Datei schreiben
        }

und sieh nach, ob in der Datei dann das steht was du erwartest.

Alternativ, und das wäre auf lange Sicht die bessere Lösung, sollte die 
Funktion

int com_geti(int *com_inputi, HANDLE hComm) {

das tun, was ihr Funktionsname verspricht: Einen Integer empfangen. 
Genau das tut sie zur Zeit nicht. Sie empfängt ein Zeichen. Ein Zeichen 
ist aber kein Integer. Um da einen Integer zu empfangen musst du solange 
Zeichen sammeln, bis eines daher kommt, welches sicher nicht mehr zur 
Zahl gehören kann. Und erst diese Sequenz von Zeichen kann in einen 
Integer umgewandelt werden.

[Karl H. (kbuchegg)]

Wenn ichs mir recht bedenke, ist die ganze Funktion

int com_geti(int *com_inputi, HANDLE hComm) {

  ClearCommError(hComm, &commerr, &comstat);
  if(comstat.cbInQue != 0 && ReadFile(hComm, com_inputi, 1, &bytes_read, NULL) != 0) 
    return TRUE;
  else 
    return FALSE;
}

ziemlicher Schwachsinn.
Du liest genau 1 Byte ein und legst das in einem int ab. Ein int hat 
aber mehr als 1 Byte und wenn man einmal nachverfolgt, wo dieser int 
herkommt, dann haben wir wieder mal: eine uninitialisierte Variable.

    int com_inputi;   
    while(1) {
        
        if( com_geti(&com_inputi, hComm) == TRUE) {   //Serielle Schnittstelle nach neuen Zeichen abfragen
            printf("%d \n", com_inputi);               //das Empfangene Zeichen in der Konsole ausgeben
            fprintf( fdatei, "%d ", com_inputi);       //das Empfangene Zeichen in die Datei schreiben
        }
    }

Da du von den Bytes, die einen int ausmachen, nur 1 Byte gezielt auf 
einen Wert setzt, ist es nicht weiter verwunderlich, dass du da auf der 
Ausgabe wilde Zahlen erhältst.

Das mindeste wäre

    int com_inputi = 0;

Aber wie bereits gesagt: Die ganze Funktion com_geti ist falsch. Sie 
macht nicht das, was sie tun sollte. Nämlich mehrere 
hintereinanderfolgende Zeichen zu empfangen und daraus eine Zahl zu 
generieren, die den empfangenen Zeichen entspricht.