Hilfe bei der write-Funktion

[LadyMarion]

Hallo,

ich habe folgende write-Funktion:

void write(const char *filename) {
	FILE *fp = fopen(filename,"wb");
	char str[2];
	str[0] = '\n';
	str[1] = '\0';
	for(int i = 0; i < (int) size(); i++) {
		fwrite(*(begin()+i),sizeof(char),strlen(*(begin()+i)),fp);
		fwrite(str,sizeof(char),1,fp);
	}
	fclose(fp);
}

Die Funktion soll nun an anderer Stelle eingesetzt werden und dafür in C++ umgeschrieben werden.
Bevor ich sie umschreiben kann, muss ich sie jedoch erstmal richtig verstehen...
Und genau da setzt es bei mir schon aus, ich weiß gar nicht wirklich, wie dieses "Schreiben" tatsächlich funktioniert.
Da die Funktion so nicht funktioniert hat, hab ich versucht, etwas zu ändern, aber jetzt wird nur eine leere Datei geschrieben.

Bin für jede Hilfe dankbar!

 

[Ryu1991]

Also unter C++ verwendet man für Dateioperationen eigentlich die fstream-Klasse

 

[MCoder]

Hallo,

die Funktion schreibt offensichtlich mehrere Zeilen eines irgendwo gespeicherten Textes in die Datei. Die Anzahl der Zeilen wird mit der Funktion "size()" ermittelt; mit "begin() + i" bekommt man jeweils einen Zeiger auf einen String. Der erste fwrite-Aufruf schreibt die Textzeile und der zweite einen Zeilenvorschub. Für das Verständnis der Funktion sind auch die Funktionen "size()" und "begin()" interessant, weil diese für den Inhalt der zu schreibenden Datei sorgen.

Gruß
MCoder

 

[devDevil]

Naja es wird einfach durch die Funktion begin() ein String zurück gegeben und der wird dann immer um ein Zeichen weiter nach vorne, ausgegeben .... (also immer um 1 kürzer)

void write(const char *filename) 
{
    FILE* file_pointer = fopen(filename, "wb");
    if (!file_pointer) return;

    const char new_line[2] = "\n";

    const char* begin = begin();
    const unsigned int length = size();
    unsigned int temp_length = strlen(begin);

    for (unsigned int i = 0; i < length; ++i) 
    {
        fwrite(*(begin + i), sizeof(char), temp_length--, file_pointer);
	fwrite(new_line, sizeof(char), 1, file_pointer);
    }
    fclose(file_pointer);
}

.. so wäre es etwas ordentlicher und performanter ... nja egal ... in C++ einfach so:

void write(std::string const& file_name) 
{
    std::ofstream file_stream(file_name.c_str(), std::ios_base::binary);
    if (!file_stream) throw std::invalid_argument("invalid filename");

    const char new_line[2] = "\n";

    const char* begin = begin();
    const std::size_t length = size();
    std::size_t temp_length = std::strlen(begin);

    for (std::size_t i(0); i < length; ++i) 
    {
        file_stream.write(*(begin + i), temp_length--);
	file_stream.write(new_line, 1);
    }
}

... so z.B. ... geht aber auch noch schöner

 

[LadyMarion]

Hallo,

erstmal danke für die Antworten, jetzt ist es mir schon ein bißchen klarer geworden.

Jetzt hab ich probiert die Funktion in meiner neuen Klasse für meine Zwecke anzupassen, aber das funktioniert noch nicht richtig.

Ich habe eine Klasse Test. In dieser wird im Konstruktor eine Datei eingelesen:

Test::Test(const string& filename)
{
    ifstream IN (filename.c_str());
    while (!IN.eof())
    {
        string line;
        getline(IN, line);
        if (IN.fail()) break;

        istringstream sstr(line);
        string s;
        sstr>>s;
        if (!s.empty())
        {
            parts = split(line);
            operator[](parts[0])=Data(parts[1]);
        }
    }
}

parts steht in der Klasse als "vector<string> parts".
Die Dateien sind immer so aufgebaut, dass dort ein Schlüssel, ein dazugehöriger Wert und evtl. noch ein Kommentar steht, also z.B. ABC, 1.23, comment
Die Werte können int, double oder string sein. Das wird in der Klasse Data unterschieden. Die Klasse Test erbt folgendes: public map<string, Data>
Somit ist die ganze Datei in einer Map gespeichert und ich kann über den Schlüssel auf jeden beliebigen Wert zugreifen.

Soweit funktioniert alles.

Jetzt hab ich eben versucht, die write-Funktion ein bißchen zu ändern. So wird aber immer nur das letzte Paar im Vector geschrieben und das jeweils in einer neuen Zeile. Ich habe es auch schon mit "line" aus dem Konstruktor oder irgendwie mit der Map selbst probiert, aber da kamen dann immer nur leere Dateien dabei heraus...

void Test::write(const char *filename)
{
	ofstream OUT(filename);
	char str[2];
	str[0] = '\n';
	str[1] = '\0';
	vector<string>::iterator iter;
	for(iter = parts.begin(); iter != parts.end(); ++iter)
        {
		OUT.write((*iter).c_str(),(*iter).length());
		OUT.write(str,1);
	}
	OUT.close();
}

Könnt Ihr mir da weiterhelfen?

 

[devDevil]

DAS klappt?

Test::Test(std::string const& filename)
{
    ifstream IN (filename.c_str());
    while (!IN.eof())
    {
        string line;
        getline(IN, line);
        if (IN.fail()) break;

        istringstream sstr(line);
        string s;
        sstr>>s;
        if (!s.empty())
        {
            parts = split(line);
            operator[](parts[0])=Data(parts[1]);
        }
    }
}

Oh man ey Wasn kranker style und soooo viel performance verlust

Test::Test(std::string const& filename)
{
    std::ifstream file_stream(filename.c_str());

    std::string line;
    while (std::getline(file_stream, line)))
    {
        parts = split(line);
        operator[](parts[0])=Data(parts[1]);
    }
}

was dann das parts = split(line) bei jedem Durchgang soll ... und ob du wirklich die split Methode brauchst und da nicht mit Interatoren rocken kannst ... ich weiß nicht