Schreiben in eine Text-Datei (und auslesen!)

SeppJ

kundendatei.open("D:\\Kundendatei\\Kundendatei.txt", ios::out);

Dies öffnet eine Datei zum Schreiben und überschreibt eine schon vorhandene Datei. Es gibt zwar auch die Möglichkeit, die Datei so zu öffnen, dass man reinschreiben und rauslesen gleichzeitig kann und auch so, dass vorhandener Inhalt nicht gelöscht wird, aber das ist vermutlich nicht das, was du möchtest. Du möchtest vermutlich jeweils lokal die Datei entweder zum Schreiben (oder mit ios::app zum anhängen) oder nur zum Lesen öffnen und nicht global für das ganze Programm.

Global ist auch das Stichwort für eine allgemeine Kritik: Wie kommt es eigentlich, dass die Leute mit den schlimmsten Programmen sich die meiste Mühe bei der Ausgabe geben? Dein Programm ist in jedweder Hinsicht grauenhaft. Wenn ich nett zu dir sein möchte, sage ich schlechter Lehrer, wenn fies sein möchte sage ich, du hast den Lehrer bisher gut geblendet. So geht das jedenfalls gar nicht, du gewöhnst dir bloß Schweinereien an, die du später nie wieder los wirst.

@Hacker: Ich glaube du wirst enttäuscht. Das ist so schlimm, da traut sich niemand mit konkreter Kritik oder Ratschlägen dran, weil man dann den ganzen Abend mit Tippen beschäftigt wäre.

Schlechter Lehrer!!!

Der hat uns gesagt wir sollen das machen, aber nur weil er selber nicht weiß wie es geht.. Und das ist nicht einfach so daher gesagt..

Könnte mir denn einer netterweise ein fertiges kleines Programm was das kann bereitstellen (ohne große Ausgabenschnickschnack :D) ? Übrigens habe ich diese Ausgabe nur gemacht weil ich lange davor saß und nicht weiter kam und dann aus Langeweile mir sowas einfallen lassen habe.. Sorry..

He, du bequeme Socke, das sah zwar aus wie eine Steilvorlage zum Eigentor für dich, aber ein wenig Einsatz deinerseits fördert die Hilfebereitschaft unsererseits.

Hast du das mit dem app schon umgesetzt?
Und versuche den Quelltext zu deinen Fragen so kurz wie möglich zu halten.

#include <cstdlib>   // brauchst du diesen Header?
#include <iostream>
#include <stdio.h>   // und diesen auch? - warum hier die C-Variante?
#include <fstream>
#include <string>

Habe jetzt mal ein bisschen was geändert.

Löschen klappt jetzt, schreiben und anhängen auch.
Vielen Dank schonmmal dafür!!!

Jetzt habe ich noch eine Frage, wie ich es gut auslesen kann.

Wenn ich es so mache, wie es jetzt im Code steht, dann ist es unformatiert, mit Tabs kann ich auch schlecht arbeiten, weil es ja mal sein kann, dass ein Vorname nur 3 Zeichen hat und mal 10.

Gibt es eine Möglichkeit das irgendwie besser zu formatieren?

Vielen Dank!

Hier der neue Code:

#include <cstdlib>
#include <iostream>
#include <stdio.h>
#include <fstream>
#include <string>

using namespace std;

const unsigned char AE = static_cast<unsigned char>(142); 
const unsigned char ae = static_cast<unsigned char>(132); 
const unsigned char OE = static_cast<unsigned char>(153); 
const unsigned char oe = static_cast<unsigned char>(148); 
const unsigned char UE = static_cast<unsigned char>(154); 
const unsigned char ue = static_cast<unsigned char>(129); 
const unsigned char ss = static_cast<unsigned char>(225); 

fstream kundendatei;
string s;
string Vorname;
string Nachname;
string Firma;
string Email;
string Telefon;
int Eingabe;

int main()
{
	kundendatei.open("D:\\Kundendatei\\Kundendatei.txt", ios::app);

	system("CLS");
	cout << endl;
	cout << " #####################################################\n";
	cout << " ##                                                 ##\n";
	cout << " #               Kundenverwaltung v1.0               #\n";
	cout << " ##                                                 ##\n";
	cout << " #####################################################\n";
	cout << endl;

	cout << " ";
	system("PAUSE");
	system("CLS");

	cout << endl;
	cout << " #####################################################\n";
	cout << " ##                                                 ##\n";
	cout << " #               Kundenverwaltung v1.0               #\n";
	cout << " ##                                                 ##\n";
	cout << " #####################################################\n";
	cout << endl;

	cout << " (1)\t\t Kunden anlegen\n";
	cout << " (2)\t\t Alle Kunden l" << oe << "schen\n";
	cout << " (3)\t\t Kunden anzeigen\n";
	cout << " (4)\t\t Programm schlie" << ss << "en\n";
	cout << endl << endl;
	cout << " Eingabe:\t ";
	cin >> Eingabe;
	system("CLS");

	if(Eingabe == 1)
	{
		cout << endl;
		cout << " #####################################################\n";
		cout << " ##                                                 ##\n";
		cout << " #               Kundenverwaltung v1.0               #\n";
		cout << " ##                                                 ##\n";
		cout << " #####################################################\n";
		cout << endl;

		cout << " Bitte ' _ ' statt einer Leertaste benutzen!" << endl << endl;
		cout << " Vorname des Kunden:\t ";
		cin >> Vorname;
		cout << endl;
		cout << " Nachname des Kunden:\t ";
		cin >> Nachname;
		cout << endl;
		cout << " Firma:\t\t\t ";
		cin >> Firma;
		cout << endl;
		cout << " Email:\t\t\t ";
		cin >> Email;
		cout << endl;
		cout << " Telefonnummer:\t\t ";
		cin >> Telefon;
		cout << endl;

		kundendatei << Vorname << " " << Nachname << "  |  " << Firma << "  |  " << Email << "  |  " << Telefon << endl;
	}
	else if(Eingabe == 2)
	{
		kundendatei.close();
		kundendatei.open("D:\\Kundendatei\\Kundendatei.txt", ios::out);

	}
	else if(Eingabe == 3)
	{
		cout << endl;
		cout << " #####################################################\n";
		cout << " ##                                                 ##\n";
		cout << " #               Kundenverwaltung v1.0               #\n";
		cout << " ##                                                 ##\n";
		cout << " #####################################################\n";
		cout << endl;

		kundendatei.close();
		kundendatei.open("D:\\Kundendatei\\Kundendatei.txt", ios::in);
		while (!kundendatei.eof())          // Solange noch Daten vorliegen
		{
			getline(kundendatei, s);        // Lese eine Zeile
			cout << " " << s << endl;    // Zeige sie auf dem Bildschirm
		}
		cout << " ";
		system("PAUSE");
	}
	else if(Eingabe == 4)
	{
		cout << endl;
		cout << " #####################################################\n";
		cout << " ##                                                 ##\n";
		cout << " #               Kundenverwaltung v1.0               #\n";
		cout << " ##                                                 ##\n";
		cout << " #####################################################\n";
		cout << endl;
		cout << " Das Programm wird nun geschlossen!\n\n";
		cout << " ";
		system("PAUSE");
		return EXIT_SUCCESS;
	}
	else
	{
		system("CLS");
		cout << " Wenn Sie dies sehen ist irgendetwas schief gelaufen!\n";
		cout << " Das Programm wird nun beendet!\n";
		cout << endl << endl;
		cout << " ";
		system("PAUSE");
		return EXIT_SUCCESS;
	}

	kundendatei.close();
	main();
}

SeppJ

Dein Code brennt an allen Ecken und Enden und du kümmerst dich um kosmetische Kleinstdetails? Na gut, sag aber in ein paar Wochen nicht, dass wir dich nicht vor deinem Pfad gewarnt hätten:
http://www.cplusplus.com/reference/iostream/manipulators/
Insbesondere setw interessiert dich wohl.

Ich mach mal einen ersten Schritt:

cout << endl;
        cout << " #####################################################\n";
        cout << " ##                                                 ##\n";
        cout << " #               Kundenverwaltung v1.0               #\n";
        cout << " ##                                                 ##\n";
        cout << " #####################################################\n";

Machste ne Funktion draus:

std::ostream& title(std::ostream& os)
{
        static const size_t amount(53);
        static const std::string programmTitle("Kundenverwaltung v1.0");
        return os << '\n'
                  << ' ' << std::string(amount, '#') << '\n'
                  << " ##" << std::string(amount - 4, ' ') << "##\n"
                  << " #" << std::string((amount - programmTitle.length() - 1) / 2, ' ') << programmTitle << std::string((amount - programmTitle.length() - 1) / 2, ' ') << "#\n"
                  << " ##" << std::string(amount - 4, ' ') << "##\n"
                  << ' ' << std::string(amount, '#') << '\n';
}

Die du so aufrufst:

std::cout << title << '\n';

Edit: verbesserte Version:

#include <iostream>
#include <string>

template<size_t amount>
std::ostream& title(std::ostream& os)
{
        static const std::string programmTitle("Kundenverwaltung v1.0");

        return os << '\n'
                  << ' ' << std::string(amount, '#') << '\n'
                  << " ##" << std::string(amount - 4, ' ') << "##\n"
                  << " #" << std::string((amount - programmTitle.length() - 1) / 2, ' ') << programmTitle << std::string((amount - programmTitle.length() - 1) / 2, ' ') << "#\n"
                  << " ##" << std::string(amount - 4, ' ') << "##\n"
                  << ' ' << std::string(amount, '#') << '\n';
}

int main()
{
      std::cout << title<43> << '\n';
}

SeppJ

@Hacker: Gib deinem Manipulator doch den Text als Parameter mit. Viel universeller als eine doofe, hardcodierte Konstante. Das könnte man dann immer wieder benutzen, ist ja sicher nicht sein einziges Programm mit dieser Art Rahmen.

Edit: erste Version:

#include <iostream>
#include <string>
#include <cassert>

template<size_t amount, char... str>
std::ostream& title(std::ostream& os)
{
        static const std::string programmTitle({str..., '\0'});
        assert(amount > programmTitle.length());

        return os << '\n'
                  << ' ' << std::string(amount, '#') << '\n'
                  << " ##" << std::string(amount - 4, ' ') << "##\n"
                  << " #" << std::string((amount - programmTitle.length() - 1) / 2, ' ') << programmTitle << std::string((amount - programmTitle.length() - 1) / 2, ' ') << "#\n"
                  << " ##" << std::string(amount - 4, ' ') << "##\n"
                  << ' ' << std::string(amount, '#') << '\n';
}

int main()
{
      std::cout << title<24, 'K', 'u', 'n', 'd', 'e', 'n', 'v', 'e', 'r', 'w', 'a', 'l', 't', 'u', 'n', 'g', ' ', 'v', '1', '.', '0'> << '\n';
}

SeppJ

Das Schlimme ist, mir ist nicht klar, ob du das ernst oder als Scherz meinst.

SeppJ schrieb:

Das Schlimme ist, mir ist nicht klar, ob du das ernst oder als Scherz meinst.

Biste bescheuert?
Das war jetzt rumspielerei XD

Abgesehen davon: PI macht es genauso, und Pi ist sehr erfahren.

314159265358979

Erstens bin ich nicht erfahren, zweitens würde ich es auch nicht so machen.

314159265358979 schrieb:

Erstens bin ich nicht erfahren, zweitens würde ich es auch nicht so machen.

Doch. Letztens (irgendwo) ging es um eine Template-Meta Version von irgendetwas, da hast du es ähnlich gemacht.. wobei vielleicht auch nur zum Spaß...

314159265358979

Das liegt daran, dass das der einzige weg ist, zur Compilezeit mit Strings zu arbeiten. Das willst du hier doch gar nicht, folglich kannst du deinenen String einfach als Parameter im Konstruktor übergeben.

SeppJ

314159265358979 schrieb:

Das liegt daran, dass das der einzige weg ist, zur Compilezeit mit Strings zu arbeiten.

Nichts, was man nicht durch genügend obskure Regelbeugung umgehen kann:

template <const char * string> void static_string_function() { }

struct static_string
{
  static const char value[];
};

const char static_string::value[] = "Hallo Welt!";

int main()
{
  static_string_function<static_string::value>();
}

Jetzt muss mir nur noch was einfallen, wie man das rekursiv benutzen kann, damit man damit auch was sinnvolles machen kann (z.B. static_strlen). Für Hackers statischen Rahmen reicht es aber jetzt schon.

@ Beitragsersteller: habt ihr schon Schleifen im Rahmen von C++ erklärt bekommen

kundendatei.close();
    main();   // das sollte man möglichst nicht so nutzen
}

Beim ersten Quelltext hattest du es auch so. Da war das aber nicht main() und somit bezogen auf den Quelltext nur nicht schön, aber gangbar.

lokale Variable - globale Variable darauf wurde hier schon etwas geschrieben. Warum ignorierst du das?

Beim ersten Quelltext hattest du eine Funktion ausser der main(). Das war schon wenig. Warum im 2. Quelltext nur noch main() Bist du Anhänger des Spaghetticode

system ("PAUSE");

brauchst du gar nicht, wenn du dein Menu mal besser sortierst.

Schon mal etwas von switch-case-break im Unterricht gehört?

Schleifen hatten wir schon, aber die brechen ja irgendwann ab (wenn ein bestimmter Wert erreicht wird?). Und ich will ja, dass es durchläuft bis man sich dazu auch entschließt. Kann auch sein, dass ich hier einfach einen Denkfehler habe, bin wie schon gesagt totaler C++ Noob.. Nur muss ich in der Schule (mache Ausbildung zum Systemintegrator, brauche daher da keine Programmierung) in Anwendungsentwicklung sowas auf die Beine stellen.

Also die main() sollte man nicht nochmal aufrufen? So hatten wir das schonmal im Unterricht in einer der vielen komischen Stunden Und meine Variablen soll ich in der main() auch deklarieren?

Soll ich mehrere Funktionen programmieren und dann in der main() nur aufrufen? Was für Funktionen sollte ich denn dann programmieren? Wenn ich die Funktionen weiß, weiß ich ja ca was da rein muss.

switch case hatten wir mal, aber ich weiß nicht mehr genau wie es geht, bzw wie ich es hier benutzen muss. Ich nehme an einfach das, was ich jetzt als if else habe als switch case?

Vielen Dank!

PS.: setw würde ja funktionieren, aber wie sage ich dem Programm, dass er nicht die komplette Zeile direkt auslesen soll, sondern nur bis zum ersten " | "? Weil sonst macht er ja die ganze Zeile..

@ Hacker, ich würde meine "Spielerei" ja gerne so machen, aber sowas hatten wir im Unterricht noch nicht, daher darf ich sowas glaube ich auch nicht nutzen..

(okay, sachen in eine Datei speichern und auslesen hatten wir auch nicht, aber das sollen wir ja explizit machen )

314159265358979

@SeppJ: Vielleicht lässt sich da ja was machen, wenn man die Länge des Arrays übergibt. Dann müsste man nur noch eine Liste aus Indizes für das Array generieren und mit s[I]... hätte man dann schließlich die einzelnen Elemente. Ich kenne leider die genauen Regeln für Zeiger als Template-Parameter nicht, daher weiß ich nicht, ob das so funktioniert. Das Array müsste dann wohl auch constexpr sein.

SeppJ

314159265358979 schrieb:

@SeppJ: Vielleicht lässt sich da ja was machen, wenn man die Länge des Arrays übergibt. Dann müsste man nur noch eine Liste aus Indizes für das Array generieren und mit s[I]... hätte man dann schließlich die einzelnen Elemente. Ich kenne leider die genauen Regeln für Zeiger als Template-Parameter nicht, daher weiß ich nicht, ob das so funktioniert. Das Array müsste dann wohl auch constexpr sein.

Ja, das constexpr ist wichtig, ohne wird es gar nicht erst ausgewertet. Aber auch mit bekomme ich es nicht recht hin. Hmm. Wird wohl einen Grund haben, warum man immer sagt, dass die Einzelne-Buchstaben-Methode der einzige Weg wäre.