Ich lerne gerade c++ ( Autodidakt mit Büchern ) und bin dabei mir eine kleine Videothek zu schreiben, um den Umgang mit Klassen zu erlernen, Konsole.

Hab eine Klasse Filme :

class filme
{
public:
	static enum sorten { SciFi=1, Horror=2, Komödie=3,Doku=4,Sport=5,Annime=6,Anderes=7 };
	static sorten enusor( int a );
	static std::string enusort( int a );
private:
	std::string titel;
	sorten genre;
	int mb;
	int wertung;
	std::string ort;
	std::string beschreibung;

public:
	filme(const std::string & t,sorten g, int smb, int wert ,const std::string wo, const std::string &besch);
	std::string getTitel() const;
	int getGenre() const;
	int getmb() const;
	int getNote() const;
	std::string getort() const;
	std::string getBeschreibung() const;
	void settitel(std::string &tit);
	void setgenre(sorten &gen);
	void setmb(int siz);
	void setwertung(int a);
	void setort(std::string &a);
	void setbeschreibung(std::string &a);
    void print();

Und eine Klasse in der ich die Filme verwalte:

class filmework
{
public:
	typedef std::vector<filme> filmliste; 

private:
	filmliste liste;
	filmliste suchestring(const std::string &a,std::string (filme::*mptr)()const) const;
	filmliste findeint(int g,int (filme::*mptr)()const) const;

	static std::string initein(const std::string &a, const std::string &b,unsigned int c);
	static int initeinN(const std::string &a, const std::string &b, int c ,int d);
	static std::string eintit;
	static std::string maxzeichen50 ;
	static std::string genretext;
	static std::string generotext;
	static std::string sizetext;
	static std::string sizeerotext;
	static std::string notentext;
	static std::string notenerotext;
	static std::string orttext;
	static std::string maxzeichen100;
	static std::string beschtext;

public:

	filmework();
	void hinzufuegen(const filme &f);
	static filme erstellefilm();
	filmliste suche();
	virtual ~filmework(void);
	filmliste sortiere();

Jetzt versuche ich Methoden für das Lesen und Speichern einzubringen,
allerdins das einfache Überladen der Shift Operatoren bringt mich da nicht wirklich weiter.

Wenn ich das Beispiel aus dem Netz nehme:
istream& operator >> (istream& is, Complex& op)
{
is >> op.real; // Real- und Imaginär-
is >> op.omag; // anteil einlesen
return is; // Referenz auf Stream zurückliefern
}

Wie kann ich hier einen Delimer angeben zwichen den Tokens des Objekts ?

Jetzt wird oft auf die Boost Serialisation verwiesen, allerdings möchte ich erst den "Weg zu Fuß gehen " um es zu verstehen.

Würde mich über Hilfe freuen.

Grüßle

MDMR

istream& operator >> (istream& is, Complex& op)
{
char delimeter;
is >> op.real; // Real- und Imaginär-

is >> delimeter; // liest einen char aus dem stream, z.b. '|'

is >> op.omag; // anteil einlesen
return is; // Referenz auf Stream zurückliefern
}

void operator>>(testklasse &tk, std::string str)
{
	std::ofstream outfile(str.c_str());
	std::ostringstream os;
	os << tk.str1 << ";" << tk.str2; // <-- du gibst jedes Element durch dein Delimiter getrennt hier an;
	outfile << os.str();

}

str1 und str2 sind hier zwei public strings von testklasse.

benutzen könnte man das dann so

testklasse tk1;
	tk1.str1 = "hallo";
	tk1.str2 = "welt";

	tk1 >> "test.txt";

Dein Delimiter wählst du selbst, in meinem Beispiel das Semikolon.

EDIT:
um mit deinen Klassen zu arbeiten solltest du dir zuvor jedoch anschauen wie man Operatoren für Klassen überlädt und nicht als globale Funktion, alternativ kannst du deine Operatorüberladung auch zum Freund deiner Klasse machen.

Eine einfachere Idee wäre jedoch einfach eine Methode zu schreiben die was speichert und lädt.

Wenn du das unbedingt mit dem Shiftoperator lösen möchtest anstatt einfach eine Methode zu schreiben die deine Objekte speichert, musst du dir zu erst überlegen wohin dein Objekt denn geschiftet werden soll.

Quark. Gerade dem Shiftoperator sollte egal sein, wo er rein schreibt!

Eine einfachere Idee wäre jedoch einfach eine Methode zu schreiben die was speichert und lädt.

.. interessante Aussage!

genau das haben MDMR und rean doch gemacht.
Nur zur Info: Die Schnittstelle für einen Input d.h. das Einlesen von irgendwas ist in C++ ein std::istream (genauer std::basic_istream<>) und die Schnittstelle für einen Output also eine Ausgabe ist std::ostream (genauer std::basic_ostream<>). cin, ifstream sind istreams und cout, ofstream sind std::ostreams.

Folglich ist eine Funktion für das Einlesen eines Objekts einer Klasse eine Funktion mit std::istream& und der betreffenden Klasse. Und üblich ist der operator>> (s. Posting von rean).

std::ostream &operator<<(std::ostream &os, const filme &val)
{
	os.clear();
    os << val.titel << '°' << val.ort << '°' << val.verzeichnis << '°' << val.beschreibung << '°' << val.genre << '°' << val.mb << '°' << val.wertung << '\n';
    return (os);
}

std::istream &operator>>(std::istream &is , filme &val)
{
	is.clear();
	char c;
    std::getline(is, val.titel,'°');
    std::getline(is, val.ort,'°');
    std::getline(is,val.verzeichnis,'°');
    std::getline(is,val.beschreibung,'°');
    is >> val.genre >> c >> val.mb >> c >> val.wertung ;
	return(is);
}