Speichern

Nathan

arkot333 schrieb:

Nathan schrieb:

Der Compiler sieht diese beim Compilen und hat dort eine feste, hartcodierte Bedeutung.

Nicht wenn sie sich in einem attribute-token befinden!

The identifiers shown in Table 4 are reserved for use as keywords (that is, they are unconditionally treated
as keywords in phase 7) except in an attribute-token (7.6.1)

*facepalm*

Achsoo, also wenn ich das richtig verstanden habe ist das std:: dafür da das man dem Compiler etwas hilft (das er sofort in die Header Datein guckt) ?
Und diese Schlüsselwörter sind in der Standartbibilothek (also kein std:: davor)?
http://de.cppreference.com/w/cpp/keyword
Und wenn "cout und cin" nicht dadrin sind muss (kann) ein std:: davor??

DerNoob schrieb:

Achsoo, also wenn ich das richtig verstanden habe ist das std:: dafür da das man dem Compiler etwas hilft (das er sofort in die Header Datein guckt) ?
Und diese Schlüsselwörter sind in der Standartbibilothek (also kein std:: davor)?
http://de.cppreference.com/w/cpp/keyword
Und wenn "cout und cin" nicht dadrin sind muss (kann) ein std:: davor??

Mach using namespace std; und vergiss erstmal std::.
In deinem Stadium lenkt das bloss vom Wesentlichen ab.

Hey.. die anderen meinten man sollte damit direkt am anfang anfange..
Ist aber auch egal ich würde das gerne verstehen warum und bei welchen man dies macht deswegen wollte ich eine Rückmeldung auf meinen Vorherigen Post ob ich das jedzt richtig verstanden habe

Nathan

DerNoob schrieb:

Achsoo, also wenn ich das richtig verstanden habe ist das std:: dafür da das man dem Compiler etwas hilft (das er sofort in die Header Datein guckt) ?

Nein, beim Compilieren gibt es keine Headerdateien mehr. Der Präprozessor bearbeitet alles mit dem # Symbol, im Fall von include nimmt er den Inhalt der Datei und fügt ihn an der Stelle im Code ein.
Das std:: sagt einfach: Suche nach der Funktion func nicht im globalen Namensraum (=außerhalb namespace), sondern im Namensraum std.

Und diese Schlüsselwörter sind in der Standartbibilothek (also kein std:: davor)?

Nein, diese Schlüsselwörter sind eben nicht in der Standardbibliothek. if und Co kannst du verwenden ohne einen Header eingefügt zu haben.

http://de.cppreference.com/w/cpp/keyword
Und wenn "cout und cin" nicht dadrin sind muss (kann) ein std:: davor??

Jein.
Schlüsselwörter - die in der Liste - sind in der Sprache eingebaut und brauchen nichts, damit sie vom Compiler verstanden werden, keine Header, keine Namespaces.
Aber nicht alles, was kein Schlüsselwort ist, muss mit std:: qualifiziert werden.
Es kommt darauf an, wo die Dinge definiert werden. Werden sie in einem Namensraum deklariert (wie in fast allen C++ Bibliotheken). muss man sie mit dem entsprechenden Namensraum qualifizieren.
Du musst einfach wissen, wo die Dinge deklariert werden. In großen Projekten ist es nicht unüblich, dass man mehrere Namensräume hat. Man muss nur wissen, was woher stammt.
Aber das geht hier eigentlich schon zu weit.
Ich empfehle dir parallel ein gutes Grundlagenbuch zu lesen. Links gibts hier im Forum. Die Autoren können das garantiert besser und chronologischer erklären als ich.

Danke Nathan für die Antwort.
Kannst du mir ein Buch empfehlen??
Ohne eine ewig lange Bücherliste und ich muss mir eins raussuchen? :p

hey nochmal zurück zum speichern..
Ich habe das in mein compiler gegeben und enie text.txt erstellt im gleichem Ordern..
Aber der Compiler sagt mir viele Fehlermeldungen

SeppJ

DerNoob schrieb:

Aber der Compiler sagt mir viele Fehlermeldungen

Dann werden da wohl Fehler sein.
http://www.c-plusplus.net/forum/200753
http://www.c-plusplus.net/forum/304133
http://www.tty1.net/smart-questions_de.html

Also vorhin hats geklappt
Nun steht da

"Der Bezweichner 'save' mehrfach deklariert"
"'save' bereits deklariert"

Und das ist mein Code:

#include <iostream>
#include <fstream>

int main (void) {

int eins =2;

    std::ofstream save("test.txt");
    save << eins;

    std::ifstream save ("test.txt");
    save >> eins;

    return 0;

}

SeppJ

DerNoob schrieb:

"Der Bezweichner 'save' mehrfach deklariert"
"'save' bereits deklariert"

Jetzt denk doch mal darüber nach, was dies wohl bedeuten mag.

DerNoob schrieb:

int eins =2;

Sehr subtil...

Ja das, dass save 2x deklariert wurde.
Ich habe es versucht ohne geht nicht..

Furble Wurble ja

Erstmal. was passiert hier?

#include <iostream>
#include <fstream>

int main (void) {

int eins =2;

    std::ofstream save("test.txt"); //du öffnest eine Datei zum schreiben (Das "o" für fstream steht for "out"
    save << eins; //du schreibst rein

    //std::ifstream save ("test.txt");
    //save >> eins;
    std::ifstream save2 ("test.txt"); //Variablenname geändert, der muss eindeutig sein - jetzt öffnest du dieselbe datei zum lesen, geht aber nicht, ist schon geöffnet!
    save2 >> eins;

    return 0;

}

Eine Alternative

#include <iostream>
#include <fstream>

int main (void) {

int eins =2;

    std::fstream save("test.txt"); //das "o" hab ich gelöscht - öffnet datei zum lesen und schreiben
    save << eins;

    //std::ifstream save ("test.txt"); //brauchen wir nicht mehr, ist ja schon geöffnet
    save >> eins;

    return 0;

}

Th69

Keine Alternative!

Der Wert ist ja noch gar nicht in die Datei geschrieben, wenn sie wieder geöffnet wird. Entweder explizit flush() verwenden oder aber besser

{
    std::ofstream save("test.txt");
    save << eins;
}

{
    std::ifstream load ("test.txt");
    load >> eins;
}

Man beachte die Blockklammerung(!) - jetzt könnte sogar beim Lesen auch 'save' als Variable verwendet werden, aber Variablennamen sollten auch sinnvoll sein!

Danke Th69. Und ich kann die Namen "save" und "load" selbst bennen?
Und wenn ja wofür ist das noch sinnvoll, oder nur für diese Stelle?

Noch eine Frage.
Angenommen ich will mehrere Variablen speichern. (z.B. eins=1, zwei=2, drei=3)
Und ich möchte die im Textdokument so haben.

Variable eins : "eins"
Variable zwei : "zwei"
Variable drei : "drei"

Geht das?
Und wenn ja wie lese ich die Daten wieder aus??

??

Erstmal hat Th69 natürlich recht das meine alternative eher Blödsinn war, das kommt davon wenn man schnell schnell macht...

Um deine Frage zu beantworten:
Ja, natürlich geht das.
Es gibt mehrere Möglichkeiten das wieder auszulesen. Prinzipiell steht in deiner Textdatei ja so eine Zeichenkette:

Variable eins : \"eins\"\nVariable zwei : \"zwei\"\nVariable drei : \"drei\"

(Ich hoffe mal die Formatierung funktioniert so wie ich will)
Deine Aufgabe ist jetzt, erstmal zu überlegen wie du so eine Zeichenkette so wieder auseinandernehmen kannst, das du deine Werte wieder rauskommen. Dazu stellt sich u.a. solche Fragen wie "sieht das immer exakt so aus, oder kann es mal mehr oder weniger Variablen zum auslesen geben?" "Wie ordne ich den Variablen im Programm die Werte der Textdatei zu?" etc etc.

Nur mal so als allgemeiner Tipp, und auch etwas wie du in Zukunft solche Probleme angehen kannst:
Schau dir die Reference von fstream an http://www.cplusplus.com/reference/fstream/fstream/ bzw http://www.cplusplus.com/reference/fstream/ifstream/ oder http://www.cplusplus.com/reference/fstream/ofstream/ je nachdem was du grade verwendest (ifstream ist zum lesen, ofstream ist zum schreiben, fstream ist beides kombiniert) und suche dir Funktionen, mit denen du deine Ziele erreichen kannst. Das geht meist schneller als nachzufragen.
Prinzipiell, da du fragst wie du etwas ausliest, sind wohl die Funktionen von istream/ifstream von interesse - je nach anforderung z.B. getline() oder get()

Noch ein kleiner Nachtrag. Die member-Funktion getline() ist nicht sooo toll zu verwenden, am ehesten würde ich die Funktion getline verwenden. std::string ist einfacher zu handhaben als ein char*

http://www.cplusplus.com/reference/string/string/getline/