Datei Öffnen, etwas schreiben usw

[cpp_beginner]

Hallo Leute,

könnt ihr mal über meine Ersten "Gehversuche" rübergucken und sagen was man so und warum evtl. nicht macht?

Hab erst vor kurzem mit c++ angefangen, also ein bisschen gnädig, wenn möglich

#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>
#define BUFF 256

/* run this program using the console pauser or add your own getch, system("pause") or input loop */

int main(int argc, char** argv) {

std::ifstream Datei_in;	

Datei_in.open("text1.txt", std::ios::in );   

if (Datei_in.fail()){
	std::cerr<<"Error opening File"<<std::endl;
	return (EXIT_FAILURE);
}

char line[BUFF]={'\0'} ;

while(!Datei_in.eof()){
	Datei_in.getline(line,BUFF);
	std::cout<<line;
	getchar();    //hmm??  Ist es "böse" C funktionen zu nutzen??
}
Datei_in.close();

std::string zusatz;

zusatz="LA LE LU ....";
zusatz += "...Nur der Mann im Mond gibt Ruh\n";
zusatz.insert(0, "\n");

std::ofstream Datei_out;

Datei_out.open("text1.txt", std::ios::app);

if(Datei_out.fail()){
	std::cerr<<"Error opening File\n"; 
	return (EXIT_FAILURE);
}

Datei_out<<zusatz;
Datei_out.close();

	return 0;
}

[Columbo]

• #define BUFF 256 warum ein Makro und keine Konstante? Der Name ist nicht sonderlich aussagekräftig.

int main(int argc, char** argv)

Du nimmst die Kommandozeilenparameter, nutzt sie aber nicht.
*  ```
std::ifstream Datei_in;

Datei_in.open("text1.txt", std::ios::in );

• Warum nicht per Konstruktor initialisieren? Selbes gilt für Datei_out weiter unten.
• Bei ifstream ist in ist schon implizit als Flag gesetzt.

std::ifstream Datei_in("text1.txt");

std::cerr<<"Error opening File"<<std::endl;

 `std::cerr` ist ungepuffert, `std::endl` ist also nicht besser als `'\n'` .
*  Warum Dinge beim `return` -Statement in Klammern setzen?
*  ```
while (!Datei_in.eof()) // Böse Abbruchbedingung - fehleranfällig und lang. Besser die Leseoperation selbst in die Abbruchbedingung reinpacken.
{
    Datei_in.getline(line,BUFF); // Ieh. Ein std::string für line wäre deutlich schöner. Dann müsste man sich nicht fixer Länge abplagen.
    std::cout << line;
    getchar(); // Kannst du durch std::cin.get() ersetzen.
}
Datei_in.close(); // Nicht schön. Besser und lesbarer wäre es gewesen beide Blöcke irgendwie in lokale Scopes zu packen. Zum Beispiel in eine Funktion.

for (std::string line; getline(Datei_in, line);)
{
    std::cout << line;
    std::cin.get();
}

std::string zusatz;

zusatz="LA LE LU ....";
zusatz += "...Nur der Mann im Mond gibt Ruh\n";
zusatz.insert(0, "\n");

Was die Zeilen hier verloren haben verstehe ich nicht. Eine Vorführung der `string` -Funktionalitäten? Von einem Tutorial kopiert? Dass man das zu  

char const zusatz[] = "\nLA LE LU .......Nur der Mann im Mond gibt Ruh\n";

vereinfachen kann ist dir hoffentlich bewusst. Ein `std::string` ist hier im Übrigen nicht nötig.
*  `Datei_out.close();` kurz vor Scope-Ende ist überflüssig. Der Destruktor von jedem Dateistream ruft ` close()` sowieso auf.
*  `return 0;` am Ende der main-Funktion passiert implizit.

[Swordfish]

Kommentare im Code:

cpp_beginner schrieb:

#include <iostream>
#include <fstream>
#include <string>
#include <cstdlib>
#define BUFF 256  // dafuer nimmt man in C keine Praeprozessorsymbole, sondern Konstanten *1)

/* run this program using the console pauser or add your own getch, system("pause") or input loop */  // *2)

int main(int argc, char** argv) {  // Wofuer Parameter, die du sowieso nicht verwendest?
	
std::ifstream Datei_in;

Datei_in.open("text1.txt", std::ios::in );  // nimm dafuer den Konstruktor.
                                            // Die Angabe von std::ios::in ist ueberfluessig,
                                            // da bei ifstream implizit gesetzt.

if (Datei_in.fail()){  // Schau dir mal ios::operator!() (C++03) und ios::operator bool() (C++11) an.
                       // Wenn du es sehr verbos ausdruecken willst, suchst du vielleicht std::ifstream::is_open().
	std::cerr<<"Error opening File"<<std::endl;
	return (EXIT_FAILURE);  // Die Klammern sind für 'd fisch'.
}

char line[BUFF]={'\0'} ;  // *eeek* ... warum char Arrays fuer Strings??

while(!Datei_in.eof()){  // *3)
	Datei_in.getline(line,BUFF);
	std::cout<<line;
	getchar();              // nein, ist nicht phoese, solange man
                                // den richtigen Header (<cstdio>) einbindet
                                // und checkt, dasz getchar im Namespace std lebt.
}
Datei_in.close();

std::string zusatz;

zusatz="LA LE LU ....";
zusatz += "...Nur der Mann im Mond gibt Ruh\n";
zusatz.insert(0, "\n");  // Warum nicht gleich hinschreiben?

std::ofstream Datei_out;

Datei_out.open("text1.txt", std::ios::app);

// ...
 
Datei_out<<zusatz;
Datei_out.close();  // close() passiert auch durch den Destruktor,
                    // wenn die Variable out-of-scope geht.
	
	
	return 0;  // ueberfluessig. main() gibt immer 0 zurueck,
                   // wenn sie nichts zurueckgibt.
}

1. Entweder ein anonymes enum:

enum { BUFF = 256 };

oder eine Konstante:

#include <cstddef>
std::size_t const BUFF = 256;

2. siehe Automatisches Schließen verhindern.

3. Du machst "Solange nicht EOF: lesen und verarbeiten". EOF wird jedoch nur bei einer versuchten Leseoperation gesetzt. Du machst also effektiv: "Solange nicht EOF: lesen und potenziell Müll verarbeiten". Du solltest aber: "Lesen versuchen und wenn kein Fehler: verarbeiten" machen.

Also:

#include <cstddef>
#include <cstdlib>
#include <cstdio>
#include <iostream>
#include <fstream>
#include <string>

std::size_t const BUFF = 256;

int main()
{   
	std::ifstream Datei_in( "text1.txt" );

	if( !Datei_in ) {
		std::cerr << "Error opening File\n\n";
		return EXIT_FAILURE;
	}

	char line[ BUFF ] = {};

	while( Datei_in.getline( line, BUFF ) ) {

		std::cout << line;
		std::getchar();
	}

	Datei_in.close();

	std::string zusatz;

	zusatz="LA LE LU ....";
	zusatz += "...Nur der Mann im Mond gibt Ruh\n";
	zusatz.insert(0, "\n");

	std::ofstream Datei_out( "text1.txt", std::ios::app );

	if( !Datei_out ) {

		std::cerr << "Error opening File\n\n";
		return EXIT_FAILURE;
	}

	Datei_out << zusatz;
}

~edith: deutsches Sprache, schweres Sprache~

[Columbo]

Swordfish schrieb:

1. Entweder ein anonymes enum (C++03):

enum { BUFF = 256 };

oder ein konstanter Ausdruck (C++11):

#include <cstddef>

std::size_t constexpr BUFF = 256;

Warum nicht einfach:

std::size_t const BUFF = 256;

Was das constexpr bei BUFF soll musst du mir mal erklären.

[Swordfish]

Aufgrund §5.19.2 muss es in diesem Fall nicht, ist aber auch nicht falsch.

[cpp_beginner]

int main(int argc, char** argv) { // Wofuer Parameter, die du sowieso nicht verwendest?

Naja, das macht meine IDE beim erstellen eines neuen Projekts automatisch, genauso wie am Ende der main das return 0.

std::string zusatz;

zusatz="LA LE LU ....";
zusatz += "...Nur der Mann im Mond gibt Ruh\n";
zusatz.insert(0, "\n");  // Warum nicht gleich hinschreiben?

Naja, das war eigentlich nur ein bisschen rumprobieren mit den string Funktionen. Ist Käse, klar.

#define BUFF 256  // dafuer nimmt man in C keine Praeprozessorsymbole, sondern Konstanten *1)

Ok, kapiert.

Datei_in.open("text1.txt", std::ios::in );  // nimm dafuer den Konstruktor.
                                            // Die Angabe von std::ios::in ist ueberfluessig,
                                            // da bei ifstream implizit gesetzt.

Ok, ehrlich gesagt ich weiß "in etwa" wie OOP funktioniert und das Grundprinzip der Klassen hab ich gecheckt, aber in meinem Buch bin ich eigentlich noch nicht soo weit und genauer angesehen hab ich´s mir auch noch nicht.
Darum ist´s jetzt mit Konstruktor und Destruktor nicht wirklich weit her bei mir (bis jetzt)

Das die Angabe von std::ios:in eigentlich überflüssig ist hab ich gelesen, habs hald der "Form" halber hingeschrieben.
=> habs auch mal mit std::ios:in | std::ios:out versucht, aber das schreiben in die Datei mit Datei_in<<"irgendwas; geht wohl nur mit ofstream oder fstream?

Schau dir mal ios::operator!() (C++03) und ios::operator bool() (C++11) an.
// Wenn du es sehr verbos ausdruecken willst, suchst du vielleicht std::ifstream::is_open().

Hmm.. ja, also ich nutzte ziemlich viel die OnlineReferenz von Cplusplus.com

Die hat mir bei 'C' immer gut geholfen. Aber mit c++ ist das alles noch Neuland und teils unverständlich für mich. Das eine gehört da hinzu, das andere getline wida ganz woanders, hier gehört wider ein std:: hin, dort wida nicht, usw usw . ..

Datei_out.close();  // close() passiert auch durch den Destruktor,
                    // wenn die Variable out-of-scope geht.

Siehe oben , Destrukotr... In C hab ich hald jede Datei die ich irgendwo aufgemacht hab, auch wida zugemacht.. ?

Danke für die vielen Antworten, einiges ist jetzt klarer, einiges sind paar Fragezeichen mehr :-))

[Columbo]

Swordfish schrieb:

Aufgrund §5.19.2 muss es in diesem Fall nicht, ist aber auch nicht falsch.

Ja, vernachlässigt aber unnötigerweise die Kompabilität zu früheren Standards.

[Swordfish]

War

size_t const size = 42;
T arr[ size ];

immer schon erlaubt? Ich bild mir ein, da war mal was anders?

[camper]

Swordfish schrieb:

War

size_t const size = 42;
T arr[ size ];

immer schon erlaubt?

ja

[Swordfish]

In dem Fall: ouch & sorry!

[cpp_beginner]

Gibt´s schon tausendmal die Frage, aber welche Bücher odter Tutorials würdet ihr für den Anfang mal Empfehlen, wenn man schon einigermaßen Programmieren kann und nicht mit "das ist ein INT Variable" anfangen will.... ?

Quasi ein "Umsteiger" Buch? Wie habt ihr mit C++ angefangen und wie lange macht ihr schon c++? Also der Umfang der Sprache ist ja wahnsinn, für mich als Anfänger leicht depremierend, wenn man hier im Forum oft Code liest und sich denkt "Was zur Hölle will der überhaupt??"

[cpp_beginner]

Noch ein Nachtrag... Warum geht die ganze Funktion auch, wenn ich #include <string> weglasse??

[asc]

cpp_beginner schrieb:

Gibt´s schon tausendmal die Frage, aber welche Bücher odter Tutorials würdet ihr für den Anfang mal Empfehlen, wenn man schon einigermaßen Programmieren kann und nicht mit "das ist ein INT Variable" anfangen will.... ?

Tutorials: Durch die Bank kein einziges. Mir ist keins bekannt das auch nur halbwegs gut und aktuell wäre.

Bücher: Von wo aus umsteigen? Von einer Sprache wie z.B. Java oder C# würde ich dir die regulären Bücher empfehlen, da die Unterschiede doch recht gravierend sein können. Ansonsten ist die Frage ob eine Referenz nicht besser ist (wie The C++ Programming Language, möglichst in der neusten Auflage).

cpp_beginner schrieb:

Wie habt ihr mit C++ angefangen und wie lange macht ihr schon c++?

Studium und Bücher. Ich programmiere seit etwa 15 Jahren beruflich C++ und lerne immer wieder neues (wobei: Inzwischen eigentlich weniger, da die verwendete IDE eh nicht die neuen Standard unterstützt, und aktuell für mich andere Sprachen wichtiger werden - wäre C++ aber weiterhin meine Hauptsprache würde ich mich stärker mit den neuen Standards beschäftigen).

C++ lernt man auch nicht eben mal, wer sich intensiv mit der Sprache beschäftigt wird mindestens ein Jahr benötigen um die Sprache wirklich zu beherrschen (Was nicht heißt, das er nicht schon früher Programme schreiben kann, manche verstehen die Sprache auch nicht nach Jahrzehnten obwohl sie anderes behaupten ;p).

[cpp_beginner]

Bücher: Von wo aus umsteigen?

Eher aus der 'C' Ecke.

C++ lernt man auch nicht eben mal, wer sich intensiv mit der Sprache beschäftigt wird mindestens ein Jahr benötigen um die Sprache wirklich zu beherrschen

Ein Jahr, wär ja toll, ich rechne mal eher mit 3 Jahren, da ich der ganzen Sache nur als "Hobby" nachgehen kann, beruflich programmiere ich im Automatisierungsektor Automobilindustrie hauptsächlich S7 und Kuka Robotik. Ganz andere Welt. Vor allem OOP ist darum ziemlich Neuland.

Studium und Bücher.

Um ersteres (und 10 Jahre jünger ) wäre ich heute froh

Ansonsten ist die Frage ob eine Referenz nicht besser ist (wie The C++ Programming Language, möglichst in der neusten Auflage

).
Tja, ich hab günstig , für 10 Euro ne Deutsche Übersetzung bekommen. Nunja... ich find nicht richtig rein in das Buch. Auf der 20 Seite sind schon Codebeispiele mit Templates und was weiß ich was für welchen Klassen,das es einem die Schuhe auszieht

[asc]

cpp_beginner schrieb:

Bücher: Von wo aus umsteigen?

Eher aus der 'C' Ecke.

C++ lernt man auch nicht eben mal, wer sich intensiv mit der Sprache beschäftigt wird mindestens ein Jahr benötigen um die Sprache wirklich zu beherrschen

Ein Jahr, wär ja toll, ich rechne mal eher mit 3 Jahren,...

Meine Betonung war auch auf mindestens. Wenn du bereits beruflich programmierst und C-Kenntnisse hast, wäre der Weg über "Die C++ Programmiersprache" eine Variante - doch programmiert man in C++ eigentlich gänzlich anders, so das weiterhin die Standardwerke wie der "C++ Primer" (ohne Namenszusatz) nicht ganz verkehrt wären. Alternativ such nach den frei verfügbaren, aber schon etwas älteren beiden "Thinking in C++"-Büchern und lese diese quer. Sie sind zwar nicht C++11, sind aber dennoch kein schlechter Einstieg. Ich würde anschließend zu den "Effective C++"-Büchern raten...

cpp_beginner schrieb:

Studium und Bücher.

Um ersteres (und 10 Jahre jünger ) wäre ich heute froh

Ich habe mein Studium damals abgebrochen, und studiere aber inzwischen wieder "nebenher" (Was man so nebenher nennen kann - Freizeit ist während der Semester jedenfalls ein Fremdwort; ein Ausschlag war wohl das es im gleichen Gebäudekomplex ist, wie meine Arbeitsstelle). Und ich beende es im Idealfall kurz vor meinem 40igsten - in dem Bereich [WiInf] liege ich zwar am oberen Altersende, in den parallel liegenden WiWi-Gängen wäre das aber vielleicht noch im Mittelfeld.

cpp_beginner schrieb:

Tja, ich hab günstig , für 10 Euro ne Deutsche Übersetzung bekommen. Nunja... ich find nicht richtig rein in das Buch. Auf der 20 Seite sind schon Codebeispiele mit Templates und was weiß ich was für welchen Klassen,das es einem die Schuhe auszieht

Dann greif zu einen der oben genannten (Primer...). Und nur am Rande: Vielen "echten" Anfängern sind die Einstiegsbücher wie Primer noch zu schwer, Vorkenntnisse müssen nicht bedeuten, das sie dir zu leicht wären.

[cpp_beginner]

Besten Dank für die ausführliche Antwort!!

Noch eine Frage, damit wäre mir momentan Verständnißmäßig geholfen:

std::fstream SHEAT ("daten_1.txt", std::fstream::in | std::fstream::out);
std::fstream SHEAT_2("daten_2.txt", std::ios::in | std::ios:out);

Beides ist irgendwie richtig. Aber was soll man jetzt hernehmen, std::fstream::in oder std::ios::in ? Ich werd echt aus der Refernz nicht ganz schlau, muss unbedingt das mit den Klassen und wer zu wem gehört usw. auf die Reihe bekommen....

Aus der Referenz:

explicit fstream (const char* filename,
                  ios_base::openmode mode = ios_base::in | ios_base::out);

Also bis filename ist alles klar ;-), aber wie komm ich jetzt auf std::fstream::in oder std::ios::in ??

Ist bestimmt ziemlich lächerlich für euch, aber wenn ich die Referenz nicht richtig interpretieren kann, hab ich bedenken das das bei mir was wird

[Swordfish]

Es ist egal, was du schreibst. Es bezieht sich immer auf std::ios_base::openmode , das von allen von std::ios_base ableitenden Klassen geerbt wird.

[cpp_beginner]

Also könnte ich auch

std::fstream SHEAT ("daten_1.txt",  std::ios_base::in );

machen?

[Nathan]

cpp_beginner schrieb:

Also könnte ich auch

std::fstream SHEAT ("daten_1.txt",  std::ios_base::in );

machen?

Ja.
Oder

std::fstream SHEAT ("daten_1.txt",  std::ostringstream::in );

Das ist völlig wurscht.

[cpp_beginner]

Leute soviel wie da geerbt wird, würd ich mir auch mal wünschen zu erben
Danke an alle für die geduldigen Antworten!