Daten in einer Datei Schreiben und lesen

[gerbej s. (sgerbej)]

Hallo zusammen!
ich bin neulinge in c++ und vesuche zwei classen Input und saveload 
zuschreiben; in input soll Funktionswerte(x und y),die ich später 
plotten möchte,ausgewertet. in zweite class saveload soll die Daten 
geschrieben bzw. gelesen werden und der Pfade soll über konsole 
eigegeben .
kann jamend mein Code kurz angucken und mir tipps geben wie ich das zum 
laufen krigen kann;

hier ist Project.h

truct XYpair{
  double x;
  double y;
  XYpair(double x, double y):x(x),y(y){}
};

class INPUT{

private:
  int psize;
  double xmin,xmax;
  int wahl;
  std::vector<XYpair> dptr;
public:
  void setvalue();
  std::vector<XYpair> Dataplot(int psize);
  int menu();
};
class Saveload{
private:
  ifstream idatei;
  ofstream odatei;
  std::vector<XYpair> Vp;
  char pfad [200];
public:
  void save(int n, std::vector<XYpair>);
  std::vector<XYpair> load();
};
#endif

Abschitt von project.cpp

std::vector<XYpair> INPUT::Dataplot(int psize){
  
  double xr=(double)(xmax-xmin)/psize;
  double X=xmin;
  int i;
  std::vector<XYpair> dptr;
  X=xmin;
  for(i=0; i<psize; i++){
    dptr.push_back(XYpair(X,sin(X)));
    X+=xr;
  }
  return dptr;
}

void Saveload::save(int n, std::vector<XYpair> v){
  
  std::vector<XYpair> Vp;
  int i;
  for(i=0;i<=n-1;i++){
    Vp[i]=v[i];
  }
  
  cout<< "Unter welchem Pfadname soll es gepeichert werden?"<< endl;
  cin>>pfad;
  idatei.open(pfad, ios::in | ios::binary);
  
  if(!idatei){cout <<"Fehler beim Öffnen neuer Datei"<<endl;}
  
  idatei.read(Vp, sizeof(Vp)/sizeof(Vp[0])); 
  
  idatei.close()
    }

std::vector<XYpair> Saveload:: load(){
  int n;
  cout<<"von welchem Pfad soll ausgelesen werden"<< endl;
  cin>>pfad;
  
  odatei.open(pfad, ios::out | ios::binary);

  if(!odatei){cout <<"Fehler beim Öffnen der Datei"<<endl;}
  std::vector<XYpair> ptr;
  odatei.write(Vp,size(n));
  for(i=0; i<n; i++)
    ptr[i]=Vp[i];
  odatei.close();
return ptr;
}

Abschitt von main.cpp

int main(){
  int Wahl;
  int psize=15;
  std::vector<XYpair> V;
  
NPUT fdata;
  Saveload pdata;
  Wahl=fdata.menu();
if(Wahl==1){
  fdata.setvalue();
  V=fdata.Dataplot(psize);
  pdata.save(psiz,V);
   }
else if(Wahl==2){
    
   V =pdata.load();
   for(int i=0; i<psize-1; i++){
      cout <<"V.x"<<V[i].x<<"V.y"<<V[i].y<<'\n';
    }

meine probleme sin  eigentlich beim Lesen und schreiben , ich habe da 
mehrere syntax Fehler.

ich bin für jeder Hilfe sehr dankbar .

Gruß
Seb

[Nico S. (nico22)]

Wie wäre es, wenn du die Fehlermeldungen vom Compiler gleich 
mitkopierst?

[gerbej s. (sgerbej)]

hier ist die Compilerfehler

g++ -c project.cpp
project.cpp: In member function ‘void Saveload::save(int, std::vector<XYpair>)’:
project.cpp:50:42: error: no matching function for call to ‘std::basic_ifstream<char>::read(std::vector<XYpair>&, unsigned int)’
project.cpp:50:42: note: candidate is:
/usr/include/c++/4.6/istream:467:7: note: std::basic_istream<_CharT, _Traits>& std::basic_istream<_CharT, _Traits>::read(std::basic_istream<_CharT, _Traits>::char_type*, std::streamsize) [with _CharT = char, _Traits = std::char_traits<char>, std::basic_istream<_CharT, _Traits>::char_type = char, std::streamsize = int]
/usr/include/c++/4.6/istream:467:7: note:   no known conversion for argument 1 from ‘std::vector<XYpair>’ to ‘std::basic_istream<char>::char_type* {aka char*}’
project.cpp:53:2: error: expected ‘;’ before ‘}’ token
project.cpp: In member function ‘std::vector<XYpair> Saveload::load()’:
project.cpp:64:25: error: ‘size’ was not declared in this scope
project.cpp:65:7: error: ‘i’ was not declared in this scope
make: *** [project

[xgast (Gast)]

Beitrag "GNU Libmatheval in C++ Programm anwenden"

1. std::vector direkt lesen oder schreiben geht nicht. Du musst jedes 
Element einzeln lesen/schreiben (und bei einem zusammengesetzten typ, 
z.B struct wieder die Elemente einzeln lesen/schreiben)
2. zeile 52 fehlt ein ;
3. size(n) evtl sizeof(n)?
4. i was not declared... compiler hat recht..
5. load und save namen sind vertauscht? load=write, save=read?

[Karl H. (kbuchegg)]

Und warum du da in den Funktionen jedesmal den std::vector erst mal 
durch die Gegend kopierst, musst du mir auch erst mal erklären.

[Karl H. (kbuchegg)]

Und noch ein Tipp:

Beim Speichern von Daten, ist es eine extrem gute Idee, wenn man vor die 
Daten erst mal rausschreibt, wieviele Daten denn überhaupt geschrieben 
werden.

Eine extrem gute Idee ist das deshalb, weil man dann beim Einlesen erst 
mal diese Anzahl einliest und dann weiß, wieviele Datensätze im File 
noch kommen werden.

Beim Schreiben einer Datei muss man sich in der Datei die Informationen 
reinschreiben, die später beim Lesen der Datei zur Steuerung des 
Lesevorgangs genutzt werden.

[Karl H. (kbuchegg)]

idatei.open(pfad, ios::in | ios::binary);
  
  if(!idatei){cout <<"Fehler beim Öffnen neuer Datei"<<endl;}
  
  idatei.read(Vp, sizeof(Vp)/sizeof(Vp[0]));

ist ja schön, wenn du deinem Benutzer mitteilst, dass du die Datei nicht 
öffnen konntest. Nur: Auf eine nicht geöffnete Datei kann man auch nicht 
schreiben/lesen. D.h. du musst das natürlich auch berücksichtigen, dass 
du einen Fehler hattest und dass du deshalb nichts Schreiben lesen 
kannst.
(Und eventuell sollte das auch der Aufrufer der Funktion wissen, dass da 
was schief gelaufen ist, damit der dann wiederrum nicht einen 
fehlerhaften std::vector in die Auswertung weitergibt)

[gerbej s. (sgerbej)]

Karl Heinz Buchegger schrieb:
> Und warum du da in den Funktionen jedesmal den std::vector erst mal
> durch die Gegend kopierst, musst du mir auch erst mal erklären.

ich denke mal das ich die daten in eine Buffer erstmal schreibe .

Karl Heinz Buchegger schrieb:
> Und noch ein Tipp:
>
> Beim Speichern von Daten, ist es eine extrem gute Idee, wenn man vor die
> Daten erst mal rausschreibt, wieviele Daten denn überhaupt geschrieben
> werden.
>
> Eine extrem gute Idee ist das deshalb, weil man dann beim Einlesen erst
> mal diese Anzahl einliest und dann weiß, wieviele Datensätze im File
> noch kommen werden.
>
> Beim Schreiben einer Datei muss man sich in der Datei die Informationen
> reinschreiben, die später beim Lesen der Datei zur Steuerung des
> Lesevorgangs genutzt werden.

void Saveload::save(int n, std::vector<XYpair> v)
n ist die Anzhal der Byte der ich schreiben möchte

read() erwartet ein char* und frage mich wie kann ich die std::vector 
übergebe

[Karl H. (kbuchegg)]

gerbej seb schrieb:
> Karl Heinz Buchegger schrieb:
>> Und warum du da in den Funktionen jedesmal den std::vector erst mal
>> durch die Gegend kopierst, musst du mir auch erst mal erklären.
>
> ich denke mal das ich die daten in eine Buffer erstmal schreibe .


Wozu?


>> Beim Schreiben einer Datei muss man sich in der Datei die Informationen
>> reinschreiben, die später beim Lesen der Datei zur Steuerung des
>> Lesevorgangs genutzt werden.
>
> void Saveload::save(int n, std::vector<XYpair> v)
> n ist die Anzhal der Byte der ich schreiben möchte

OK. Kann man so machen. Muss man aber nicht. Der std::vector weiß selber 
wie gross er ist. Du brauchst ihn nur 'fragen'. Dieselbe Information 
(nämlich die Anzahl der Wertpaare) 2 mal im System zu haben, ist immer 
ein 'Ask for trouble'. Alte Datenbankweisheit: Speichere dieselbe Info 
niemals 2 mal ab. Im besten Fall passiert nichts. Im schlimmsten Fall 
stimmen die beiden Angaben nicht überein. Welche der beiden stimmt denn 
dann?

Und rechne besser nicht damit, dass du immer den besten Fall vorliegen 
hast.

>
> read() erwartet ein char* und frage mich wie kann ich die std::vector
> übergebe

gar nicht.
Du liest 2 double ein (denn die hast du auch geschrieben), konstruierst 
daraus ein XYPair Objekt, welches du mit push_back an den std_vector 
anhängst.

Und genauso kannst du den std::vector nicht einfach in write 
hineingeben, sondern musst das Element für Element machen. Ein Element 
nach dem anderen aus dem std::vector herausholen und die Werte dieses 
Elements in die Datei schreiben.

Das hat aber xgast kurz vor 19:00 schon angemerkt.


Hast du denn kein C++ Buch?
Ich wiederhole es gerne nochmal: Online Tutorien sind kein Ersatz für 
ein ordentliches Buch!

[Karl H. (kbuchegg)]

Und ehe du dich an binären Files versuchst, schlage ich vor, dass du 
erst mal ganz normale Text-Files erstellst und wieder einliest. Denn 
dann kannst du mit jedem ordinären Texteditor kontrollieren, ob das 
File, das du geschrieben hast auch wirklich in Ordnung ist. In deinem 
Stadium ist nichts schlimmer als Stochern im Nebel, weil du nicht weißt 
ob dein Einlese-Code falsch ist oder ob der Rausschreiben-Code schon 
eine ungültige Datei erzeugt hat.

[gerbej s. (sgerbej)]

das zu mindest was mir der copmiler mitteilt

project.cpp:50:20: error: no matching function for call to ‘std::basic_ifstream<char>::read(std::vector<XYpair>&, int&)’
project.cpp:50:20: note: candidate is:

das read() ein parameter von typ char

[gerbej s. (sgerbej)]

danke für deinen Vorschlag das werde ich jetzt versuchen normale 
Test-file zu erstellen

[Karl H. (kbuchegg)]

#include <iostream>
#include <vector>
#include <string>

struct XYpair
{
  XYpair(double x, double y):x(x),y(y){}

  double x;
  double y;
};


class Saveload
{
  public:
    bool save( const std::vector<XYpair>& data );
    bool saveTo( const std::string& fileName, const std::vector<XYpair>& data );

    std::vector<XYpair> load();
    std::vector<XYpair> loadFrom( const std::string& fileName );

  private:
    std::string askForPath( const std::string& question );
};

#include <iostream>
#include <fstream>
#include <string>
#include "Plotter.h"

using namespace std;

////////////////////////////////////////////////////////////////////////
//
std::string Saveload::askForPath( const std::string& question )
{
  std::string pfad;

  cout << question << endl;
  cin >> pfad;

  return pfad;
}

////////////////////////////////////////////////////////////////////////
//
bool Saveload::save( const std::vector<XYpair>& data )
{
  std::string fileName = askForPath( "auf welche Datei soll geschrieben werden" );
  
  return saveTo( fileName, data );
}

////////////////////////////////////////////////////////////////////////
//
bool Saveload::saveTo( const std::string& fileName, const std::vector<XYpair>& data )
{
  ofstream outFile;

  outFile.open( fileName.data() );
  if( !outFile ) {
    cout << "Konnte Datei " << fileName << " nicht zum Schreiben öffnen" << endl;
    return false;
  }

  outFile << data.size() << "\n";

  for( size_t i = 0; i < data.size(); ++i )
    outFile << data[i].x << " " << data[i].y << "\n";

  outFile.close();

  return true;
}
  
////////////////////////////////////////////////////////////////////////
//
std::vector<XYpair> Saveload::load()
{
  std::string fileName = askForPath( "von welchem Pfad soll ausgelesen werden" );

  return loadFrom( fileName );
}

////////////////////////////////////////////////////////////////////////
//
std::vector<XYpair> Saveload::loadFrom( const std::string& fileName )
{
  ifstream inFile;
  std::vector<XYpair> result;

  inFile.open( fileName.data() );
  if( !inFile ) {
    cout << "Konnte Datei " << fileName << " nicht zum Schreiben öffnen" << endl;
    return result;
  }

  size_t size;

  inFile >> size;
  for( size_t i = 0; i < size; ++i ) {
    double x, y;
    inFile >> x >> y;
    result.push_back( XYpair( x, y ) );
  }

  inFile.close();

  return result;
}

// *********************************** //
void dumpData( const std::vector<XYpair>& data )
{
  for( size_t i = 0; i < data.size(); ++i )
    cout << i << ": " << data[i].x << " " << data[i].y << "\n";
}

int main()
{
  std::vector<XYpair> data;
  Saveload Filemanager;

  data.push_back( XYpair( 1.0, 1.0 ) );
  data.push_back( XYpair( 2.0, 3.0 ) );
  data.push_back( XYpair( 3.0, 2.0 ) );
  data.push_back( XYpair( 4.0, 0.0 ) );

  cout << "Originaldaten\n";
  dumpData( data );

  cout << "Saving to file\n";
  Filemanager.saveTo( "c:\\data.txt", data );

  cout << "Reading back from file\n";
  std::vector<XYpair> copy;
  copy = Filemanager.loadFrom( "c:\\data.txt" );

  cout << "This is, what I read from file\n";
  dumpData( copy );

  cout << "Now you can save the data\n";
  Filemanager.save( copy );

  return EXIT_SUCCESS;
}