Schreiben in eine Text-Datei (und auslesen!)

[Deniska93]

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.

[Gast]

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.

[Gast]

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.

[Gast]

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.

[Gast]

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.

[f.-th.]

@ 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?

[Deniska93]

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!

[Deniska93]

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..

[Deniska93]

@ 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.

[Gast]

Deniska93 schrieb:

@ 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..

Hahaha! Neinneinnein, es geht hundertmal einfacher. Warte, ich bastele jetzt mal an der Version mit SeppJs Idee.
Obwohl ich garnicht wusste, dass Zeiger zur Compilezeit bekannt sein können

[314159265358979]

Fast hab ichs. Nur noch ein doofer Fehler vonwegen constant expression. Die Regeln müsste man kennen.
http://ideone.com/suS7n

[SeppJ]

314159265358979 schrieb:

Fast hab ichs. Nur noch ein doofer Fehler vonwegen constant expression. Die Regeln müsste man kennen.
http://ideone.com/suS7n

Irgendwie kommt mir das alles sehr bekannt vor. Das hat mich vor Jahren mal von Templatemetaprogrammierung zu Makrometaprogrammierung gebrcht, da ich so ein Konstrukt unbedingt brauchte und es nicht hinbekam. Und von da war es nur ein kleiner Schritt den ganzen Metakram wieder ganz aufzugeben :p .

Aber das war als C++11 noch (ernsthaft!) C++0x hieß, da hatte ich noch keine constexpr.