Speichern

CppNeuland

Schau mal hier nach http://de.cppreference.com/w/. Schluesselwoerter sind Teil der Sprache C++ und Klassen und Funktionen, die mit den C++ Compilern ausgeliefert werden, gehoeren zur Standardbibliothek von C++, deswegen auch der Namensraum std::

Welche dies nun sind muss du halt lernen.

Also müsste ich mich hinsetzen und alles Schlüsselwörter von dem

#include <iostream.h>

lernen damit ich weiß ob ich davor std:: machen. Oder würde das reichen wenn ich die Schlüsselwörter lerne die keine Header Datei benötigen und bei dem Rest einfach ein std:: davor mache?

Sry für Doppelpost, aber ich glaube langsam verstehe ich es
Die Standartbibilothek muss ich nicht einbinden??
Und wenn ja ist das immer die gleiche?

Nathan

DerNoob schrieb:

Also müsste ich mich hinsetzen und alles Schlüsselwörter von dem
#include <iostream.h>
lernen damit ich weiß ob ich davor std:: machen. Oder würde das reichen wenn ich die Schlüsselwörter lerne die keine Header Datei benötigen und bei dem Rest einfach ein std:: davor mache?

Halt, du verstehst etwas falsch.
Der Header heißt iostream ohne .h!
Ich hole mal weit aus:
Ein Schlüsselwort ist ein elementarer Bestandteil der Sprache. Sie werden genutzt um die grundlegenden Mittel der Sprache zu verwenden.
Beispiele sind if, for, class, int, etc. Der Compiler sieht diese beim Compilen und hat dort eine feste, hartcodierte Bedeutung.
Aber allein mit Schlüsselwörtern kann man kein Programm schreiben. Man kann zwar eine Variable erzeugen, z.B. vom Typen int, aber man kann sie weder einlesen lassen noch auslesen lassen.
Da IO ein elementare Bestandteil von jedem Programm ist, dachte man sich: Es wär doch toll, wenn man automatisch Dinge zur Verfügung haben könnte, die IO machen.
Diese Dinge sind in C++ die Klassenhierachie rund um istream und ostream. Damit der Compiler weiß, was das ist, benötigt er die Deklarationen der Funktionen. Da steht drin die Funktion mit dem Namen get() verlangt keine Argumente und liefert einen char zurück. Damit kann er überprüfen, ob der Anwender get() richtig verwendet. Diese Deklarationen stehen u.a. in der Headerdatei iostream (ohne .h). Der Linker weiß im nachfolgenden Schritt aber immer noch nicht, was get() macht. Dazu schaut er in der Bibliotheksdatei nach (da, wo die kompilierten Definitionen der Funktionen stehen) und macht Anpassungen am Code.
Jede Bibliothek funktioniert nach diesem Prinzip. Man muss dem Compiler sagen, wo er die Headerdateien mit den Deklarationen findet und wo er die Bibliotheksdatei mit den Definitonen findet. Da es sich bei iostream aber um einen Bestandteil der Standardbibliothek handelt, wird das automatisch gemacht.
Und alle Sachen der Standardbibliothek sind grundlegende Funktionen und Klassen, die man in fast jedem Programm braucht. Es sind aber keine eingebauten Schlüsselwörter.
Und um Namenskonflikte zu vermeiden befinden sich all diese Funktionen und Klassen im namespace std. using namespace std sagt dem Compiler nur: Wenn du xy nicht im globalen Namensraum findest, such auch im Namensraum std.
Mehr macht das nicht.

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)

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?