✔ mehrmals x Zeichen aus Datei auslesen

B

bastionmancher

Mitglied
Hallo,
ich will eine bestimmte Anzahl (als Beispiel jetzt 10) Zeichen aus einer .txt Datei auslesen diese verarbeiten und dann die nächsten 10 Zeichen einlesen. Anfangs dachte ich, dass man das irgenwie mit getline() machen könnte. Aber dabei hat sich das Problem ergeben, dass bei einem Zeilenumbruch der string wieder geleert und nur mit der letzten Zeile gefüllt wurde.
Am liebsten wäre mir, wenn die Vorschläge in C++ wären. C ist aber besser als gar nichts. Wenn ihr also nur eine Idee in C habt bin ich auch für die dankbar.
Danke schon im voraus für eure Hilfe.
bastionmancher
 
Hallo,
ich will eine bestimmte Anzahl (als Beispiel jetzt 10) Zeichen aus einer .txt Datei auslesen diese verarbeiten und dann die nächsten 10 Zeichen einlesen.
Zum Vergrößern anklicken....
Hallo auch,
probiere mal folgenden Codeschnipsel aus. Ich habs nicht getestet, aber vielleicht reicht es aus für den Anfang.
Code: 
#include <iostream>
#include <fstream>
using namespace std;

// bitte dafuer sorgen, dass "buffer" mindestens "anzahl + 1" Zeichen groß ist!
bool LeseMehrereZeichen(ifstream& ifs, char* buffer, int anzahl) {
   for (int i = 0; i < anzahl; ++i) {
     if (ifs.eof())
      return false;       // Dateiende erreicht.
    else
       ifs >> buffer[i];
   }

  buffer[i] = `\0`;    // string immer artig mit Nullbyte abschliessen
  return true;        // geschafft!
}

int main(int argc, char** argv) {
  ifstream ifs("testdatei.txt");
  if (ifs) {
    char buffer(11);
    while (LeseMehrereZeichen(ifs, buffer, 10))
      cout << buffer << endl;
  }
  cout << "Das war´s." << endl;
  return 0;
}
Grüße OS
 
Mein Beitrag hierzu:
C++: 
#include <fstream>
#include <iostream>
#include <string>
#include <vector>

int main(int argc, char **argv)
{
    if (argc < 3)
        return 1;
        
    std::ifstream fStreamIn(argv[1]);
    
    if (!fStreamIn.is_open())
        return 2;

    std::string queue = "";
    std::string row = "";
    unsigned int amountPerSection = atoi(argv[2]);

    if (amountPerSection < 1)
    {
        std::cout << "! amountPerSection was given ZERO or non NUMERICAL value. Setting to 1 !" << std::endl << std::endl;
        amountPerSection = 1;
    }
    
    std::vector<std::string> sectionList;
    
    while (std::getline(fStreamIn, row))
    {
        queue += row;
        
        unsigned int queueLen = queue.length();
        
        if (queueLen < amountPerSection)
        {
            std::cout << "Not enought in the queue, try to read next line!" << std::endl;
            continue;
        }
        
        sectionList.push_back(queue.substr(0, amountPerSection));
        queue = queue.substr(amountPerSection, queueLen-amountPerSection);
        std::cout << "Got next section, try to read next line." << std::endl;
    }
    
    std::cout << "Reached end of file." << std::endl;
    
    fStreamIn.close();
    std::cout << std::endl << "Read sections: " << sectionList.size() << std::endl;

    unsigned int queueLen = queue.length();

    if (queueLen != 0)
    {
        std::cout << "Incomplete data left: " << queueLen << std::endl;
        sectionList.clear();
        return 3;
    }
    
    // TODO: do something with the sections in sectionList
    sectionList.clear();
    return 0;
}

Eigentlich ganz simpel. In der while schleife hängt er an queue immer das an was
gelesen wurde. Wenn der queue mindestens amountPerSection Zeichen enthält
amountPerSection Zeichen vom string von anfang an als teilstück an den vector
anhängen. Am Ende wird nur noch überprüft ob Zeichen in queue übrig geblieben sind,
wenn ja, war anzahlAusgelesenerZeichen % amountPerSection != 0. Das kann dann
wie ich es inerpretiere unvollständige Daten sein oder halt extra
Dateiformatinformationen am ende der Datei.
 
Hi.

@Onkel Schuppig: Von der Verwendung der eof() Methode ist abzuraten. Außerdem prüfst du nicht ob überhaupt ein Zeichen eingelesen wurde - was dazu führt das dein Code nicht vorhersagbar funktioniert.

Und warum so kompliziert? Ein istream besitzt doch die Methode get():
C++: 
#include <fstream>
#include <string>

using namespace std;

int main() {
  char buf[11];
  const unsigned int len = sizeof(buf)/sizeof(*buf);
  string text;
  ifstream datei("...");

  while (datei.get(buf, len)) {
    cout << buf << endl;
    text += buf;
  }
}
Es werden in der Schleife immer (len - 1) Zeichen eingelesen und mit einem abschließenden \0 Zeichen in buf gespeichert. Der gesamte Text wird im std::string "text" gespeichert.

Wenn nicht genug Zeichen eingelesen werden konnten (vorzeitiges Dateiende) oder ein anderer Fehler auftritt, wird die Schleife abgebrochen.

Gruß
 
Danke erst mal für eure schnelle Hilfe.

Aber wie kann ich denn zwischenspeichern, wo das Programm beim letzten Aufruf der Funktion aufgehört hat einzulesen. Das brauch ich, um beim nächsten Aufruf der Funktion dort weiterlesen zu können.
 
bastionmancher hat gesagt.:
Danke erst mal für eure schnelle Hilfe.

Aber wie kann ich denn zwischenspeichern, wo das Programm beim letzten Aufruf der Funktion aufgehört hat einzulesen. Das brauch ich, um beim nächsten Aufruf der Funktion dort weiterlesen zu können.
Zum Vergrößern anklicken....
Der aktuelle gelesene Wert steht doch in "buf" drin. Der gesamte Text steht in "text".

Was willst du denn jetzt eigentlich machen? Entweder brauchst du den gesamten Text oder du brauchst nur die zuletzt gelesenen Zeichen - oder brauchst du beides? Es ist doch aber auch beides da - ich verstehe nicht wo da jetzt das Problem ist?!

Gruß
 
mein Problem ist, dass ich immer nur Programme finde oder selber schreibe, die nur die letzte Zeile ausgeben, oder jetzt bei deinem Programm nur die erste Zeile einlesen.
Eines meiner Programme, welches nur die letzte Zeile ausgibt ist folgendes:
Code: 
#include<iostream>
#include<fstream>
using namespace std;

int main()
{
	string text;
	ifstream einlesen;
	einlesen.open("test.txt", ios::in);
	while(getline(einlesen, text));
	cout<<text<<endl;
	einlesen.close();
	system("pause");
}

Ich vermute, dass das daran liegt, dass der string bei einem zeilenumbruch anscheinend wieder von vorne gefüllt wird und der bisherige Inhalt überschrieben wird.
Was ich brauche ist ein Programm, das alle Zeilen in einen string schreibt. Es wäre auch kein Problem, wenn es erst die erste Zeile einliest, diese dann verarbeitet, danach die zweite Zeile und so weiter. Ich hab auch schon probiert, die Zeichen als char zwischen zu speichern und die zeilenumbrüche herauszufiltern. Hat aber nicht geklappt.
Hier noch einmal zusammenfassend, was das Programm tun soll:

1. Zeile wird eingelesen
2. Zeile wird verarbeitet
3. Schritte 1 und 2 werden wiederholt
...
4. EOF ist erreicht
5. Die Funktion soll verlassen werden

Ich hoffe, dass ihr mir wenigstens Tipps in die richtige Richtung geben könnt.
Gruß
bastionmancher
 
bastionmancher hat gesagt.:
mein Problem ist, dass ich immer nur Programme finde oder selber schreibe, die nur die letzte Zeile ausgeben, oder jetzt bei deinem Programm nur die erste Zeile einlesen.
Zum Vergrößern anklicken....
Du müßtest einfach die Programme nur richtig übernehmen.
bastionmancher hat gesagt.:
Eines meiner Programme, welches nur die letzte Zeile ausgibt ist folgendes:
Code: 
	while(getline(einlesen, text));
Zum Vergrößern anklicken....
Du hast hier eine leere Anweisung (das Semikolon) für die Schleife notiert. D.h. in der Schleife passiert nichts und die Schleife ist auch schon beim Semikolon zu ende.
C++: 
while (getline(einlesen, text)) {
  // ...
}
Gruß
 
Zuletzt bearbeitet:
Danke deepthroat. Wie leicht so ein kleiner Fehler das ganze Programm kaputt macht. ^^ Hätte ich selber wahrscheinlich noch lange gesucht, bis ich das gefunden hätte. Jetzt klappt jedenfalls alles. Danke noch mal.
bastionmancher
 
Um antworten zu können musst du eingeloggt sein.

Neue Beiträge

Zurück