bool streamwork::write_file(const string line,STREAM stream)
{
    if (stream == build)
    {
        m_file.open(m_file_name.c_str(), ios::out | ios::app);
        getline(m_file,line);
        return m_file;
    }
    .....
    ......
    .......
}

m_file ist eine fstream Elementvariable.

ERROR:

Project : Console application
Compiler : GNU GCC Compiler (called directly)
Directory : H:\C++ Projekte\Finanzplaner CB\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: streamwork.cpp
streamwork.cpp: In member function bool streamwork::write_file(std::string, STREAM)': streamwork.cpp:15: error: no matching function for call togetline(std::fstream&, const std::string&)'
Process terminated with status 1 (0 minutes, 0 seconds)

Da Du aber in Deinen Funktionsparametern von write_file eine konstante Kopie von line erwartest (was in der Form sowieso unnötig ist, da Du Kopien von Haus aus nicht verändern kannst, und diese deshalb nicht als const deklarieren musst), schlägt auch std::getline fehl, da line natürlich beschreibbar sein muss.

Da:

bool streamwork::write_file(const string line,STREAM stream)

Wenn Du eine Referenz auf line übergibst, kann dann auch in diesen String geschrieben werden. (Falls das so vorgesehen ist von Dir). Also so:

bool streamwork::write_file(string &line,STREAM stream)

#include "streamwork.hpp"
#include <iostream>
#include <fstream>
#include <string>
using namespace std;

bool streamwork::write_file(const string &line,STREAM stream)
{
    if (stream == build)
    {
        m_file.open(m_file_name.c_str(), ios::out | ios::app);
        getline(line,m_file); //vertauscht
        return m_file;
    }
}

Project : Console application
Compiler : GNU GCC Compiler (called directly)
Directory : H:\C++ Projekte\Finanzplaner CB\
--------------------------------------------------------------------------------
Switching to target: default
Compiling: streamwork.cpp
streamwork.cpp: In member function bool streamwork::write_file(std::string&, STREAM)': streamwork.cpp:15: error: no matching function for call togetline(std::basic_string<char, std::char_traits<char>, std::allocator<char> >&, std::fstream&)'
Process terminated with status 1 (0 minutes, 0 seconds)

line ist nun eine Referenz, und m_file ist nicht konstant.

MfG
Stromberg

istream& getline( istream& is, string& s)

...und wenn Du nun im ersten Parameter anstatt einen Filestream einen string übergibst, kann das so natürlich nicht funktionieren. So wie Du es im ersten Beispiel gehabt hast, so passt es auch. Oh Gott, schon nach 0:00... in sechs Stunden muss ich raus, also verabschiede ich mich mal.

Du versuchst in eine konstante Variable etwas neues einzulesen. Fällt Dir beim Lesen dieses Satzes auf, was sich da beißt?

Nicht nur das...

an dem Namen der Funktion (streamwork::write_file) würde ich tippen das er schreiben will, getline dient aber dem einlesen...

cu André

LordJaxom schrieb:

Du versuchst in eine konstante Variable etwas neues einzulesen. Fällt Dir beim Lesen dieses Satzes auf, was sich da beißt?

Nicht nur das...

an dem Namen der Funktion (streamwork::write_file) würde ich tippen das er schreiben will, getline dient aber dem einlesen...

cu André

ios::out | ios::app implizieren das auch...

Richtig?

Weil ich hab gedacht mit getline kann man auch etwas Zeilenweise in eine Datei reinschreiben.

MfG
Stromberg

Also wenn ich dass richtig verstanden habe, kann man mit geline nur aus einer Datei AUSLESEN...und nicht in eine Datei etwas REINSCHREIBEN?

Was impliziert den der Name "getline" anderes? ;p

Stromberg schrieb:

Weil ich hab gedacht mit getline kann man auch etwas Zeilenweise in eine Datei reinschreiben.

Nein, hier kannst du aber einfach Streamoperationen nehmen...

m_file << line << std::endl;

cu André

char engvok[200];
char gervok[200];
ifstream InFile;
    InFile.open(pszDATEI);
        if (!InFile)
    {
        cout << "Fehler beim Oeffnen der Datei!\n";
        exit(1);
    }

    InFile >> engvok >> gervok;

        InFile.close();

Der getline-Befehl muss ja anscheinend dem InFile >>... folgen, da dieser ja die erste Zeile ausliest. Wie muss denn dann der getline-Befehl für die zweite zeile lauten?

#include <iostream>
#include <fstream>

using namespace std;
char engvok[256];
char gervok[256];
const char* const pszDATEI = "vok_db.txt";
int main() {
            string a,b,c,...           

    ifstream InFile;

    InFile.open(pszDATEI);
        if (!InFile)
    {
        cout << "Fehler beim Oeffnen der Datei!\n";
        exit(1);
    }

    getline(InFile, a);
    getline(InFile, b);
    getline(InFile, c);
...

        InFile.close();

cout<<a<<"\n"<<b<<"\n"<<c<<"\n"...;
system("Pause");
}

Gibt es da keine einfachere und elegantere Lösung als diese?

std::string vokabels[1000]; // 1000 Vokabeln
std::vector<std::string> vokabels2; // Dynamisches Array

Du kannst dann ja ganz einfach auf die strings zugreifen.

for (int i = 0; i < 1000; i++)
    getline (InFile,vokabels[i]);

So was in der Art.

using namespace std

Edit: Habs jetzt, weiß was falsch war.

std::string vokabels[1000];
std::vector<std::string> vokabels2; 
for (int i = 0; i < 1000; i++)   {                
    getline (InFile,vokabels[i]);                 

}               
        InFile.close();                     
   system("cls");               
    cout <<vokabels2<<"\n";

Sieht vielleicht irgendjemand den Fehler bei meinem Script?

cout <<vokabels2<<"\n";

Es existiert kein Ausgabeoperator für vector<string>. Das kannst du aber schön in einer Schleife machen (gibt noch mehr Möglichkeiten).
also

std::vector<std::string> vokabels2;
std::string tstr;
for (int i = 0; i < 1000; i++)   {                
    getline (InFile,tstr);     // in temporäre variable einlesen            
    vokabels2.push_back(tstr); // in den vector kopieren                                          
}              
InFile.close();   // nicht zwingend nötig                 
system("cls");
size_t size = vokabels2.size(); //Größe des vectors feststellen
for( size_t i=0; i<size; ++i)             
    cout << vokabels2[i] <<"\n"; // einzelne Elemente ausgeben

#include <iostream>
#include <fstream>
#include <vector>

using namespace std; 
char engvok[200]; 
char gervok[200];
const char* const pszDATEI = "vok_db.txt"; 
int main() {
    system("cls"); 
    ifstream InFile;       
    InFile.open(pszDATEI); 
        if (!InFile)       
    {
        cout << "Fehler beim Oeffnen der Datei!\n"; 
        exit(1);                                    
    }    
std::vector<std::string> vokabels2; // Dynamisches Array 
std::string tstr;                                  
for (int i = 0; i < 1000; i++)   {           
    getline (InFile,tstr);                         // in temporäre variable einlesen 
    vokabels2.push_back(tstr);                     // in den vector kopieren   
}               
       InFile.close();                            
       system("cls");
   size_t size = vokabels2.size();                 // Größe des Vektors 
   for(size_t i=0; i<size; ++i) 
       cout <<vokabels2[i]<<"\n";                  

   system("Pause");                                
}