#include <iostream>
#include <fstream>

using namespace std;

int main(int argc, char *argv[])
{
ifstream file;
char buchstabe;
char wait;

file.open("C:/test.txt", ios::in);

if (file.good())
{
// Wenn die Datei geoeffnet werden konnte...

// An den Anfang der Datei springen
file.seekg(0L, ios::beg);

if (! file.eof())
{
// Die Datei zeilenweise auslesen
file.get(buchstabe);
}
// Ausgabe
cout << buchstabe;
}
cin.get(wait);
return 0;
}

könnt ihr mir helfen?
Geht das auch in objekorientierten Bereich?

also so ?

// read a file into memory
#include <iostream>
#include <fstream>
using namespace std;

int main () {
  int length;
  char * buffer;

  ifstream is;
  is.open ("test.txt", ios::binary );

  // get length of file:
  is.seekg (0, ios::end);
  length = is.tellg();
  is.seekg (0, ios::beg);

  // allocate memory:
  buffer = new char [length];

  // read data as a block:
  is.read (buffer,length);
  is.close();

  cout.write (buffer,length);

  delete[] buffer;
  return 0;
}

class File
{
  public:
   void Loadfile(fstream FILE, char *Filnemae);
   void Savefile(fstream FILE, char *Filememory, char *New_Filememory, char *Modus);
}

 void File::Loadfile(fstream FILE, char *Filename, char *Modus)
{
 FILE.open(Filename, Modus);
};

 void File::Savefile(fstream FILE, char *Filememory, char *New_Filememory, char *Modus)
{
 FILE.seekg(Filememory, Modus);
 FILE.get(New_Filememory);
};

Vom Aufbau her kannste das so in der OOP machen, obwohl das Beispiel bestimmt nicht mit den richtigen Befehlen ist, da ich mich nie so richtig mit Dateioperationen beshcäftigt habe, Aufruf ist ja klar, oder?
Naja, Beispiel:

//Klasse blablabla
 int main(void)
{
 File Textfile; //Objekt von Klasse
 TextFile.Loadfile(File, "Test.txt", "ios::in"); //Methodenaufruf mit  
 Methodendeklarierung

So, hilft dir vielleicht, tschau...

Hä? Du möchtest einen Bezeichner haben list aber Zeilenweise aus? Schildere dein Problem mal, Junge.
Und das mit der OOP, das lohnt sich hierbei ehrlich gesagt, ist aber machbar, sprich:

Sry, der Satz sollte so lauten:
Hä? Du möchtest einen Bezeichner haben liest aber Zeilenweise aus? Schildere dein Problem mal, Junge. Und das mit der OOP, das lohnt sich hierbei ehrlich gesagt nicht, ist aber machbar, sprich:

#include<iostream>
#include<fstream>
#include<string>

int main()
{
   std::ifstream datei("deinedatei.txt");
   std::string zum_fuellen;

   while(getline(datei,zum_fuellen));//nachdem die durchgelaufen ist, sollte alles aus der datei in "zum_fuellen" sein.

//hier kannst du dann mit dem string machen was du willst.
}

...
  // string
  std::string str;

  // reverse
  str.reverse(length);

  // read data as a block:
  is.read (str.c_str(), length);
  ..

Also dass das nicht geht weiß ich auch aber gibts da irgendwie so ne
möglichkeit direkt an den buffer von std::string ranzukommen ?

Wir sind hier im C++ Forum von daher würde ich das so machen.

#include<iostream>
#include<fstream>
#include<string>

int main()
{
   std::ifstream datei("deinedatei.txt");
   std::string zum_fuellen;
   
   while(getline(datei,zum_fuellen));//nachdem die durchgelaufen ist, sollte alles aus der datei in "zum_fuellen" sein.

//hier kannst du dann mit dem string machen was du willst.
}

Wäre es eine optimierung wenn man erst noch die Länge des Files bestimmt
und dann schon mal speicherplatz mit reverse reserviert ?

Danke Firefighter das funzt!

.. aber nur dann, wenn die Textdatei nicht mehr als eine Zeile enthält.

Besser:

#include <fstream>
#include <iomanip>      // noskipws
#include <iostream>
#include <iterator>     // istream_iterator
#include <string>

int main() 
{ 
    using namespace std;
    ifstream datei("C:/test.txt");
    string zum_fuellen( (istream_iterator< char >( datei >> noskipws )), istream_iterator< char >() );
    // jetzt steht der Inhalt von 'datei' in 'zum_fuellen'
    return 0;
}

das 'noskipws' sorgt dafür, dass auch die Leerzeichen und Zeilenumbrüche mit gelesen werden.

DataByte schrieb:

Wäre es eine optimierung wenn man erst noch die Länge des Files bestimmt
und dann schon mal speicherplatz mit reverse reserviert ?

wahrscheinlich nicht. Das Anfordern von Speicher im Rechner geht meistens schneller, als irgendein Dateizugriff.

Gruß
Werner

Google12 schrieb:

Danke Firefighter das funzt!

.. aber nur dann, wenn die Textdatei nicht mehr als eine Zeile enthält.

Besser:

#include <fstream>
#include <iomanip>      // noskipws
#include <iostream>
#include <iterator>     // istream_iterator
#include <string>

int main() 
{ 
    using namespace std;
    ifstream datei("C:/test.txt");
    string zum_fuellen( (istream_iterator< char >( datei >> noskipws )), istream_iterator< char >() );
    // jetzt steht der Inhalt von 'datei' in 'zum_fuellen'
    return 0;
}

das 'noskipws' sorgt dafür, dass auch die Leerzeichen und Zeilenumbrüche mit gelesen werden.

Aber durch das while geht er doch alle Zeilen durch und speichert sie, oder ?

DataByte schrieb:

Wäre es eine optimierung wenn man erst noch die Länge des Files bestimmt
und dann schon mal speicherplatz mit reverse reserviert ?

wahrscheinlich nicht. Das Anfordern von Speicher im Rechner geht meistens schneller, als irgendein Dateizugriff.

Gruß
Werner

Ich hätte gedacht dass std::string, wenn er daten bekommt immer einen passenden
Speicherbereich reservieren muss und dann alles von dem alten
in den neuen umkopieren muss. Und wenn die datei sehr viele zeilen hat,
Dann muss er das ziemlich oft machen. deshalb wäre es nicht doch schneller
erst zu reservieren und dann zu kopieren ?

Aber durch das while geht er doch alle Zeilen durch und speichert sie, oder ?

Genau, er speichert immer die ganze Zeile in dem selben String. Hängt sie aber eben nicht an. Am Ende enthält der String also die letzte Zeile der Datei, mehr nicht.

DataByte schrieb:

Ich hätte gedacht dass std::string, wenn er daten bekommt immer einen passenden
Speicherbereich reservieren muss und dann alles von dem alten
in den neuen umkopieren muss. Und wenn die datei sehr viele zeilen hat,
Dann muss er das ziemlich oft machen. deshalb wäre es nicht doch schneller
erst zu reservieren und dann zu kopieren ?

Da Speicheroperationen aber verhältnismäßig schnell sind im Vergleich zu Dateioperationen, ists eventuell günstiger, ein paarmal den Stringinhalt durch den Speicher zu flippern als sich mit seekg & Co erstmal die Länge der atei zu bestimmen. Wie weit welche Methode günstiger ist hängt ab von Dingen wie Speicherzugriffszeit, Größe der Datei, Größe des filebufs in fstream, anfängliche Größe und Vergrößerungsfaktor des internen String-Datenbereiches, Dateizugriffszeit, ...

Wie bei jeder Optimierung sollte der Code hier nur dann verkompliziert werden, wenn genau die Stelle einen merklichen Performancenachteil bringt, und das ist keine Sache für Schätzungen sondern für Studien mit einem Profiler...

zum_fuellen+=zum_fuellen;

so sollte es dann hinhauen.oder man nimmt einen vector und schmeißt sie da rein.

Sorry mein Fehler, natürlich muss in die while noch ein

zum_fuellen+=zum_fuellen;

so sollte es dann hinhauen.oder man nimmt einen vector und schmeißt sie da rein.

Aber bitte nicht vergessen, dass getline das Newline abschneidet

Grüssli