Gruß
Manuh

Auch wenn es nerct, aber du solltest dir Tutorials durchlesen und dann konkrete Fragen stellen. Wenn du das ganze nicht nur in der Konsole, sondern in Win-Look machen willst, kommt natürlich noch mehr Arbeit auf dich zu, aber es macht Spass, also ran an die Buletten.

chrische

#include <iostream>
#include <stdlib.h>
#include <conio.h>
#include <time.h>

using namespace std;

int main(){
time_t timestamp;
struct tm *dolle_zeit;
timestamp = time(0);
dolle_zeit = localtime(&timestamp);
printf("%d.%d.%d", dolle_zeit->tm_mday,dolle_zeit->tm_mon +1,dolle_zeit->tm_year+1900 );
cout<<"           Willkommen zum Hausaufgaben Verwalter"<<endl;

cout<<""<<endl;
system("PAUSE");
}

eingefügt, ich weiß nun nur nich genau wie es verwirklicht werden soll, dass es mittels Datum den Stundenplan scannen kann, und wie ich dann danach abgefragt werden kann.
Ich schaue mich ja schon viel in Tutorials um, nur ich denke das man durch selbst geschriebene Programme die meiste Erfahrung gewinnt und es auch mehr Spaß macht da die Idee von einem selbst kommt.

Gruß
Manuh

time_t timestamp;
struct tm *dolle_zeit;
timestamp = time(0);
dolle_zeit = localtime(&timestamp);
printf("%d.%d.%d", dolle_zeit->tm_mday,dolle_zeit->tm_mon +1,dolle_zeit->tm_year+1900 );

etwa c++? Ich habe diesen Code im Internet gefunden

Gruß
Manuh

PS: Weil soweit ich weiß ist printf() auch eine c++ Funktion

struct aufgabe_termin
{
    time_t timestamp; 
    string hausaufgabe;

};

class hausaufgaben
{
public:
    hausaufgaben() { dateneinlesen();}
    ~hausaufgaben() { datensichern();}

    void eingabe();
    void ausgabe();

private:
    vector<aufgabe_termin> mycontainer;   // dafür brauchste die struct
                                          // ... wird Zauberei!
    void dateneinlesen();
    void datensichern();
    void sortieren();
    void suchen();
};

PS: Weil soweit ich weiß ist printf() auch eine c++ Funktion

Hmm ... ganz ehrlich? NEIN!

Hmm ... die Zeitfunktionen sind nun mal alle in C ...

#include <iostream>
#include <ctime>

int main()
{
	time_t	time_current;
	time(&time_current);

	std::cout << "-\t\tWillkommen zum Hausaufgaben Verwalter\t\t-" << std::endl;
	std::cout << ctime(&time_current) << std::endl;

	return 0;
}

sollte es aber dennoch heißen ...

Mein Vorschlag, entwerfe erst mal eine Struktur und eine Klasse , mach dir Gedanken über die Aufgaben die deine Klasse erledigen muss und welche Funktionen sie brauchen wird und stell hier deinen Entwurf für die Klasse vor.
Mal als Beispiel:

struct aufgabe_termin
{
    time_t timestamp; 
    string hausaufgabe;

};

class hausaufgaben
{
public:
    hausaufgaben() { dateneinlesen();}
    ~hausaufgaben() { datensichern();}
    
    void eingabe();
    void ausgabe();

private:
    vector<aufgabe_termin> mycontainer;   // dafür brauchste die struct
                                          // ... wird Zauberei!
    void dateneinlesen();
    void datensichern();
    void sortieren();
    void suchen();
};

Danke auch wenn ich mit meinen Kenntnissen noch nicht soweit bin das genau zu kapieren, ich werde es denke mal trotzdem irgendwie benutzen wenn ichs dank Eurer Hilfe shcaffen werde, ich möchte auch nicht unbedingt das der Stundenplan erst im Programm abgefragt wird sondern schon vordefiniert ist, das mit dem Nachträglichen selbst bestimmung des Stundenplans kann ich später noch machen.

Speichern soll er es einfach in einer Lesbaren .txt datei, die nicht per Algorythmus verschlüsselt werden soll.

Die eingabe der neuen Hausaufgabe mache ich doch dann nun am besten mit einem
cin>>eingabe oder? Brauch ich denn nicht für jede Hausaufgabe eine neue Deklaration weil wenn ich dann z.b. die Deutschhausaufgaben in der Eingabe definiere ist dort ja kein Platz mehr für andere Fächer oder sehe ich hier was falsch?
Gruß und vielen Dank
Manuel!

Gruß

struct aufgabe_termin // Jede einzellne Hausaufgabe
{
    time_t timestamp; // Der Zeitpunkt der Aufgabe
    string hausaufgabe; // Und was du machen sollst ...

};

class hausaufgaben
{
public:
    hausaufgaben() { dateneinlesen();} // Halt beim erstellen der Klasse direkt mal die Daten(also die ganzen Hausaufgaben) einlesen
    ~hausaufgaben() { datensichern();} // Und beim zerstören auch wieder alles speichern ...

    void eingabe(); // halt ne neue hausaufgabe eingeben ...
    void ausgabe(); // alle hausaufgaben ausgeben ...

private:
    std::vector<aufgabe_termin> mycontainer; // Ein Vektor ist sozusagen ein dynamischer Array ... vereinfacht fürs Verständnis ;) ... also da packst du dann mit push_back ne neue Hausaufgabe rein ... 
    void dateneinlesen(); // Die Funktion zum einlesen der Hausaufgaben (siehe kontruktor)
    void datensichern(); // Zum Speichern(siehe Destruktor) 
    void sortieren(); // Die Hausaufgaben nach irgendwelchen Kriterien sortieren ...
    void suchen(); // Nach irgendwas suchen ...
};

#include <iostream>
#include <stdlib.h>
#include <time.h>
#include <conio.h>

using namespace std;
struct aufgabe_termin // Jede einzellne Hausaufgabe
{
    time_t timestamp; // Der Zeitpunkt der Aufgabe
    string hausaufgabe; // Und was du machen sollst ...

};

class hausaufgaben
{
public:
    hausaufgaben() { dateneinlesen();} // Halt beim erstellen der Klasse direkt mal die Daten(also die ganzen Hausaufgaben) einlesen
    ~hausaufgaben() { datensichern();} // Und beim zerstören auch wieder alles speichern ...

    void eingabe(); // halt ne neue hausaufgabe eingeben ...
    void ausgabe(); // alle hausaufgaben ausgeben ...

private:

    void dateneinlesen(); // Die Funktion zum einlesen der Hausaufgaben (siehe kontruktor)
    void datensichern(); // Zum Speichern(siehe Destruktor)
    void sortieren(); // Die Hausaufgaben nach irgendwelchen Kriterien sortieren ...
    void suchen(); // Nach irgendwas suchen ...
};

int main(){
    int auswahl;

    time_t    time_current;
    time(&time_current);

    std::cout << "-\t\tWillkommen zum Hausaufgaben Verwalter\t\t-" << std::endl<<endl<<endl;

    std::cout << "Heute ist ";
    std::cout << ctime(&time_current) << std::endl;
    cout<<"Was moechtest du tun:"<<endl;
    cout<<"1. Hausaufgaben eingeben"<<endl;
    cout<<"2. Hausaufgaben erledigen"<<endl;
    cin>>auswahl;
    cout<<"Du hast dich fuer "<<auswahl<<" entschieden"<<endl;
    cout<<"Viel Spass!"<<endl;

getch();
    cout<<"Fuer Heute sind folgende Aufgaben zu erledigen: "<<endl;
    cout<<ausgabe<<endl;

if (auswahl==1)
{ cout<<eingabe<<endl;
}
if (auswahl==2)
{
    cout<<ausgabe<<endl;
}    
else 
{ 
    cout<<"Falsche Eingabe, bitte Programm erneut ausfueren"<<endl;
}

   system("PAUSE");
}

Dann schreib mal die eingabe() Funktion fertig und teste Sie, poste sie, wenn du sie fertig hast. Versuch auch Fehler bei der Eingabe abzufangen.
mfg Mit welchem Compiler und Betriebssystem arbeitest du? Mich wundert das getch(); und system() in deinem Code.

Gruß
manuh

Edit: Soll ich für jedes Fach extra eine "void eingabe" schreiben, oder gibt es eine Möglichkeit alles in eines zu packen, anonsten müsste ich jedes Fach einzeln Definieren, damit man da dann seine Hausaufgaben rein schreibem kann

Ich benutz den Dev-C++ Compiler und Windows XP,
Soll ich für jedes Fach extra eine "void eingabe" schreiben, oder gibt es eine Möglichkeit alles in eines zu packen, anonsten müsste ich jedes Fach einzeln Definieren, damit man da dann seine Hausaufgaben rein schreibem kann

Nein brauchst Du nicht!

struct aufgabe_termin 
{ 
    int Unterrichtsfach; // = Sortierkriterium
    time_t timestamp;    // = Sortierkriterium
    string hausaufgabe; 
};

das wird nach jeder Eingabe in den vector gepusht und ist erstmal verstaut.
Schreib die Eingabefunktion so wie du es für richtig hälst.
mfg

... hab jetzt nur die Klasse korrigiert und die daraus folgenden Funktionsänderungen auch in der main geändert ... aber da lässt sich noch einiges rausholen

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <ctime>

struct work_entry
{
    unsigned short	subject;
    time_t			timestamp;
	std::string		work;

	work_entry() : subject(0), timestamp(0) {}
};

class HomeworkManager
{
public:
    HomeworkManager() {}  //dateneinlesen();}
    ~HomeworkManager() {} //datensichern();}

public:
	void insert_item(const work_entry&);
	void show_item(const short); // -1 == all entrys

public:
	void add_subject(const std::string&);
	void list_subjects(void);

public:
	void sort(const bool); // ascending

public:
	bool read_file(const std::string&);
	bool write_file(const std::string&);

private:
	std::vector<work_entry>		m_works;
	std::vector<std::string>	m_subjects;
};

void HomeworkManager::insert_item(const work_entry& entry)
{
	m_works.push_back(entry);
}

void HomeworkManager::show_item(const short id)
{
	if (id == -1)
	{
		for (size_t item = 0; item < m_works.size(); ++item)
			std::cout << m_works[item].work << " | " << m_works[item].timestamp << std::endl;
	}
	else if (id > 0 && static_cast<unsigned short>(id) < m_works.size())
	{
		std::cout << m_works[id].work << " | " << m_works[id].timestamp << std::endl;
	}
}

bool my_sort_asc(const work_entry& l, const work_entry& r)
{
	return l.timestamp < r.timestamp;
}

bool my_sort_desc(const work_entry& l, const work_entry& r)
{
	return l.timestamp > r.timestamp;
}

void HomeworkManager::sort(const bool ascending)
{
	std::sort(m_works.begin(), m_works.end(), (ascending == true ? my_sort_asc : my_sort_desc));
}

void HomeworkManager::add_subject(const std::string& subject)
{
	m_subjects.push_back(subject);
}

void HomeworkManager::list_subjects(void)
{
	std::cout << "* Subjects: " << std::endl;
	for (size_t item = 0; item < m_subjects.size(); ++item)
		std::cout << "\t" << (item + 1) << ": " << m_subjects[item] << std::endl;
}

int main()
{
	HomeworkManager manager;
	manager.add_subject("Deutsch");
	manager.add_subject("Physik");
	manager.add_subject("Mathematik");

	std::cout << "-\t\tHomeworkManager V0.1\t\t-" << std::endl;
	unsigned short selection = 0;
	while (selection != 3)
	{
		std::cout << "* Menu" << std::endl;
		std::cout << "\t(1) Add new item" << std::endl;
		std::cout << "\t(2) Show items" << std::endl;
		std::cout << "\t(3) Exit" << std::endl;

		std::istringstream ss;
		std::string string_input;

		do {
			std::getline(std::cin, string_input);
			ss.clear();
			ss.str(string_input);
			ss >> selection;
		} while (!ss || selection > 3);

		switch (selection)
		{
		case 1:
			{
				std::cout << "* New entry: " << std::endl;
				manager.list_subjects();
				work_entry entry;
				std::cout << "\n\tUnterrichtsfach: " << std::flush;
				do {
					std::getline(std::cin, string_input);
					ss.clear();
					ss.str(string_input);
					ss >> entry.subject;
				} while (!ss);
				std::cout << "\tWork: " << std::flush;
				std::getline(std::cin, entry.work);
				entry.timestamp = time(NULL);
				manager.insert_item(entry);
			} break;
		case 2:
			{
				manager.show_item(-1);
			} break;
		}
	}
}

std::istringstream ss;

Leider immer ein Compiler Error :

103 C:\Dev-Cpp\et+.cpp aggregate `std::istringstream ss' has incomplete type and  cannot be defined

void HomeworkManager::show_item(const short id)
{
    if (id == -1)
    {
        for (size_t item = 0; item < m_works.size(); ++item)
            std::cout << m_works[item].work << " | " << m_works[item].timestamp << std::endl;
    }
    else if (id > 0 && static_cast<unsigned short>(id) < m_works.size())
    {
        std::cout << m_works[id].work << " | " << m_works[id].timestamp << std::endl;
    }
}

in

void HomeworkManager::show_item(const short id)
{
    if (id == -1)
    {
        for (size_t item = 0; item < m_works.size(); ++item)
            std::cout << m_works[item].work << " | " << m_works[item].subject << std::endl;
    }
    else if (id > 0 && static_cast<unsigned short>(id) < m_works.size())
    {
        std::cout << m_works[id].work << " | " << m_works[id].subject << std::endl;
    }
}

änder, steht dort dann auch nur die Zahl die dem Fach zugeordnet wurde!

Vielen Dank schonmal!

Gruß
Manuh

void HomeworkManager::show_item(const short id)
{
    if (id == -1)
    {
        for (size_t item = 0; item < m_works.size(); ++item)
            std::cout << m_works[item].timestamp << " | " << m_works[item].work << " | " << (m_works[item].subject > m_subjects.size() ? "Unknown" : m_subjects[m_works[item].subject - 1]) << std::endl;
    }
    else if (id > 0 && static_cast<unsigned short>(id) < m_works.size())
    {
        std::cout << m_works[id].timestamp << " | " << m_works[id].work << " | " << (m_works[id].subject > m_subjects.size() ? "Unknown" : m_subjects[m_works[id].subject - 1]) << std::endl;
    }
}

So ... damit du das auch vestehst ...

if (m_works[item].subject > m_subjects.size()) // Er soll gucken, ob die ID, die als Fach vom Benutzer
    // angegeben wurde, überhaupt als Fach bei uns registriert ist ...
    std::cout << "Unknown"; // Ist es nicht der Fall soll er "Unknown" ausgeben, d.h. wir wissen es halt 
    // nicht wie das Fach heißt ...
else
    m_subjects[m_works[item].subject - 1] // An sonsten wissen wir halt wie es heißt und wir wollen, 
    // das er uns den Namen ausgibt. Also nehmen wir die ID des Faches und geben die einfach mal aus ;) 
    // Und das -1 kommt da noch hin, weil wir beim ausgeben der Subject-Liste hingegangen sind und
    // haben einfach eins dazu addiert ... das muss hier wieder wech ;)

So sieht mein Sourcecode bis jetzt aus:

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <ctime>
#include <sstream>

using namespace std;

struct work_entry
{
    unsigned short    subject;
    time_t            timestamp;
    std::string        work;

    work_entry() : subject(0), timestamp(0) {}
};

class HomeworkManager
{
public:
    HomeworkManager() {}  //dateneinlesen();}
    ~HomeworkManager() {} //datensichern();}

public:
    void insert_item(const work_entry&);
    void show_item(const short); // -1 == all entrys

public:
    void add_subject(const std::string&);
    void list_subjects(void);

public:
    void sort(const bool); // ascending

public:
    bool read_file(const std::string&);
    bool write_file(const std::string&);

private:
    std::vector<work_entry>        m_works;
    std::vector<std::string>    m_subjects;
};

void HomeworkManager::insert_item(const work_entry& entry)
{
    m_works.push_back(entry);
}

void HomeworkManager::show_item(const short id)
{
    if (id == -1)
    {
        for (size_t item = 0; item < m_works.size(); ++item)
            std::cout << m_works[item].work << " - " << (m_works[item].subject > m_subjects.size() ? "Unbekannt" : m_subjects[m_works[item].subject - 1]) << std::endl;
    }
    else if (id > 0 && static_cast<unsigned short>(id) < m_works.size())
    {
        std::cout << m_works[id].timestamp << " | " << m_works[id].work << " | " << (m_works[id].subject > m_subjects.size() ? "Unbekannt" : m_subjects[m_works[id].subject - 1]) << std::endl;
    }
}

bool my_sort_asc(const work_entry& l, const work_entry& r)
{
    return l.timestamp < r.timestamp;
}

bool my_sort_desc(const work_entry& l, const work_entry& r)
{
    return l.timestamp > r.timestamp;
}

void HomeworkManager::sort(const bool ascending)
{
    std::sort(m_works.begin(), m_works.end(), (ascending == true ? my_sort_asc : my_sort_desc));
}

void HomeworkManager::add_subject(const std::string& subject)
{
    m_subjects.push_back(subject);
}

void HomeworkManager::list_subjects(void)
{
    std::cout << "* Subjects: " << std::endl;
    for (size_t item = 0; item < m_subjects.size(); ++item)
        std::cout << "\t" << (item + 1) << ": " << m_subjects[item] << std::endl;
}

int main()
{
    HomeworkManager manager;

    manager.add_subject("Deutsch");
    manager.add_subject("Englisch");
    manager.add_subject("Mathematik");
    manager.add_subject("Technik");
    manager.add_subject("Geschichte");
    manager.add_subject("Medien");
    manager.add_subject("Kunst");
    manager.add_subject("Religion");
    manager.add_subject("Biologie");
    manager.add_subject("Erdkunde");
    manager.add_subject("Sport");
    manager.add_subject("Politik");
    manager.add_subject("Chemie");
    std::cout << "-\t\tHomeworkManager V0.1\t\t-" << std::endl;
    unsigned short selection = 0;
    while (selection != 3)
    {
        std::cout << "* Menu" << std::endl;
        std::cout << "\t(1) Add new item" << std::endl;
        std::cout << "\t(2) Show items" << std::endl;
        std::cout << "\t(3) Exit" << std::endl;

        std::istringstream ss;
        std::string string_input;

        do {
            std::getline(std::cin, string_input);
            ss.clear();
            ss.str(string_input);
            ss >> selection;
        } while (!ss || selection > 3);

        switch (selection)
        {
        case 1:
            {
                std::cout << "* New entry: " << std::endl;
                manager.list_subjects();
                work_entry entry;
                std::cout << "\n\tUnterrichtsfach: " << std::flush;
                do {
                    std::getline(std::cin, string_input);
                    ss.clear();
                    ss.str(string_input);
                    ss >> entry.subject;
                } while (!ss);
                std::cout << "\tWork: " << std::flush;
                std::getline(std::cin, entry.work);
                entry.timestamp = time(NULL);
                manager.insert_item(entry);
            } break;
        case 2:
            {
                manager.show_item(-1);
            } break;
        }
    }
}

Wisst ihr wie ich das machen könnte?
Vielen Dank schonmal

Gruß
Manuh

main.cpp

#include <iostream>
#include <string>
#include <sstream>
#include "homeworkmanager.h"

int main()
{
	HomeworkManager manager("test.svf");
	/* Das nur beim 1. mal ausführen ... danach rausnehmen, da auch die Fächer aus der Datei ausgelesen werden ... das erlaubt dir bsw dem User eine Funktion zum hinzufügen von eigenen Fächern zu bieten ...
	manager.add_subject("Deutsch");
	manager.add_subject("Physik");
	manager.add_subject("Mathematik");
	*/

	std::cout << "-\t\tHomeworkManager V0.1\t\t-" << std::endl;
	unsigned short selection = 0;
	unsigned short menu_item_count = 0;
	do
	{
		menu_item_count = 0;
		std::cout << "* Menu" << std::endl;
		std::cout << "\t(" << ++menu_item_count << ") Add new item" << std::endl;
		std::cout << "\t(" << ++menu_item_count << ") Show items" << std::endl;
		std::cout << "\t(" << ++menu_item_count << ") Sort" << std::endl;
		std::cout << "\t(" << ++menu_item_count << ") Mark as done!" << std::endl;
		std::cout << "\t(" << ++menu_item_count << ") Exit" << std::endl;

		std::istringstream ss;
		std::string string_input;

		do {
			std::cout << "\tInput: " << std::flush;
			std::getline(std::cin, string_input);
			ss.clear();
			ss.str(string_input);
			ss >> selection;
		} while (!ss || selection > menu_item_count);

		switch (selection)
		{
		case 1:
			{
				std::cout << "* New entry: " << std::endl;
				manager.list_subjects();
				work_entry entry;
				do {
					std::cout << "\n\tSubject: " << std::flush;
					std::getline(std::cin, string_input);
					ss.clear();
					ss.str(string_input);
					ss >> entry.subject;
				} while (!ss);
				std::cout << "\tWork: " << std::flush;
				std::getline(std::cin, entry.work);
				entry.timestamp = time(NULL);
				manager.insert_item(entry);
			} break;
		case 2:
			{
				std::cout << "* Show Item: " << std::endl;
				std::cout << "\t(-1) All Items" << std::endl;
				std::cout << "\t(x) Item number" << std::endl;
				short item = -1;
				do {
					std::cout << "\n\tInput: " << std::flush;
					std::getline(std::cin, string_input);
					ss.clear();
					ss.str(string_input);
					ss >> item;
				} while (!ss || item < -1);
				manager.show_item(item);
				manager.sort(false);
			} break;
		case 3:
			{
				std::cout << "* Sort: " << std::endl;
				std::cout << "\t(0) Ascending" << std::endl;
				std::cout << "\t(1) Descending" << std::endl;
				bool sort = false;
				do {
					std::cout << "\tInput: " << std::flush;
					std::getline(std::cin, string_input);
					ss.clear();
					ss.str(string_input);
					ss >> sort;
				} while (!ss);
				manager.sort(!sort);
			} break;
		case 4:
			{
				std::cout << "* Mark as done: " << std::endl;
				unsigned short id = 0;
				do {
					std::cout << "\tItem-ID: " << std::flush;
					std::getline(std::cin, string_input);
					ss.clear();
					ss.str(string_input);
					ss >> id;
				} while (!ss);
				manager.delete_item(--id);
			} break;
		}
	} while (selection != menu_item_count);
	return 0;
}

HomeworkManager.h

#if !defined(HOMEWORK_MANAGER_H__INCLUDED)
#define HOMEWORK_MANAGER_H__INCLUDED

#pragma once

#include <iostream>
#include <vector>
#include <string>
#include <algorithm>
#include <ctime>
#include <fstream>

struct work_entry
{
    unsigned short    subject;
    time_t            timestamp;
    std::string        work;

    work_entry() : subject(0), timestamp(0) {}
};

class HomeworkManager
{
public:
	HomeworkManager(const std::string&);
    ~HomeworkManager();

public:
    void insert_item(const work_entry&);
    void show_item(const short); // -1 == all entrys
    bool delete_item(const unsigned short&);

public:
    void add_subject(const std::string&);
    void list_subjects(void);

public:
    void sort(const bool);

public:
    bool read_file(const std::string&);
    bool write_file(const std::string&);

private:
    std::vector<work_entry>		m_works;
    std::vector<std::string>		m_subjects;
    const std::string			m_filename;
};

#endif // HOMEWORK_MANAGER_H__INCLUDED

HomeworkManager.h

#include "HomeworkManager.h"

HomeworkManager::HomeworkManager(const std::string& filename) : m_filename(filename)
{
	read_file(m_filename);
}

HomeworkManager::~HomeworkManager(void)
{
	write_file(m_filename);
}

void HomeworkManager::insert_item(const work_entry& entry)
{
    m_works.push_back(entry);
}

void HomeworkManager::show_item(const short id)
{
	if (id == -1)
	{
		for (size_t item = 0; item < m_works.size(); ++item)
			std::cout << "ID: " << (item + 1) << " :: " << m_works[item].timestamp << " | " << m_works[item].work << " | " << (m_works[item].subject > m_subjects.size() ? "Unknown" : m_subjects[m_works[item].subject - 1]) << std::endl;
	}
	else if (id > 0 && static_cast<unsigned short>(id) < m_works.size())
	{
		std::cout << m_works[id].timestamp << " | " << m_works[id].work << " | " << (m_works[id].subject > m_subjects.size() ? "Unknown" : m_subjects[m_works[id].subject - 1]) << std::endl;
	}
}

bool my_sort_asc(const work_entry& l, const work_entry& r)
{
    return l.timestamp < r.timestamp;
}

bool my_sort_desc(const work_entry& l, const work_entry& r)
{
    return l.timestamp > r.timestamp;
}

void HomeworkManager::sort(const bool ascending)
{
    std::sort(m_works.begin(), m_works.end(), (ascending == true ? my_sort_asc : my_sort_desc));
}

void HomeworkManager::add_subject(const std::string& subject)
{
    m_subjects.push_back(subject);
}

void HomeworkManager::list_subjects(void)
{
    std::cout << "* Subjects: " << std::endl;
    for (size_t item = 0; item < m_subjects.size(); ++item)
        std::cout << "\t" << (item + 1) << ": " << m_subjects[item] << std::endl;
} 

bool HomeworkManager::write_file(const std::string& filename)
{
	std::ofstream file_stream;
	file_stream.open(filename.c_str(), std::ios::out | std::ios::binary);

	if (file_stream.is_open() == false || file_stream.good() == false)
		return false;

	// File Content:
	//		size_t				Subject Count
	//		size_t				Item Count
	//		Item:
	//			time_t				time
	//			size_t				string_len
	//			char[string_len]	work
	//			unsigned short		subject
	//		Subject:
	//			size_t				string_len
	//			char[string_len]	subject

	size_t subject_count = m_subjects.size();
	file_stream.write(reinterpret_cast<char*>(&subject_count), sizeof(size_t));
	if (file_stream.good() == false)
		return false;

	size_t works_count = m_works.size();
	file_stream.write(reinterpret_cast<char*>(&works_count), sizeof(size_t));
	if (file_stream.good() == false)
		return false;

	for (size_t item = 0; item < works_count; ++item)
	{
		char*	item_work		= const_cast<char*>(m_works[item].work.c_str());
		size_t	item_work_len	= m_works[item].work.length();
		file_stream.write(reinterpret_cast<char*>(&m_works[item].timestamp), sizeof(time_t));
		file_stream.write(reinterpret_cast<char*>(&item_work_len), sizeof(size_t));
		file_stream.write(item_work, item_work_len);
		file_stream.write(reinterpret_cast<char*>(&m_works[item].subject), sizeof(unsigned short));

		if (file_stream.good() == false)
			return false;
	}

	for (size_t item = 0; item < subject_count; ++item)
	{
		char*	item_subject		= const_cast<char*>(m_subjects[item].c_str());
		size_t	item_subject_len	= m_subjects[item].length();
		file_stream.write(reinterpret_cast<char*>(&item_subject_len), sizeof(size_t));
		file_stream.write(item_subject, item_subject_len);
	}

	file_stream.close();

	return true;
}

bool HomeworkManager::read_file(const std::string& filename)
{
	std::ifstream file_stream;
	file_stream.open(filename.c_str(), std::ios::in | std::ios::binary);

	if (file_stream.is_open() == false || file_stream.good() == false)
		return false;

	size_t subject_count = 0;
	file_stream.read(reinterpret_cast<char*>(&subject_count), sizeof(size_t));
	if (file_stream.good() == false)
		return false;
	m_subjects.reserve(subject_count);

	size_t works_count = 0;
	file_stream.read(reinterpret_cast<char*>(&works_count), sizeof(size_t));
	if (file_stream.good() == false)
		return false;
	m_works.reserve(works_count);

	for (size_t item = 0; item < works_count; ++item)
	{
		size_t			item_work_len	= 0;
		work_entry		entry;

		file_stream.read(reinterpret_cast<char*>(&entry.timestamp), sizeof(time_t));
		file_stream.read(reinterpret_cast<char*>(&item_work_len), sizeof(size_t));
		char * item_work = new char [item_work_len + 1];
		file_stream.read(item_work, item_work_len);
		item_work[item_work_len] = '\0';
		file_stream.read(reinterpret_cast<char*>(&entry.subject), sizeof(unsigned short));

		entry.work = item_work;
		m_works.push_back(entry);
		delete [] item_work;

		if (file_stream.good() == false)
			return false;
	}

	for (size_t item = 0; item < subject_count; ++item)
	{
		size_t	item_subject_len	= 0;
		file_stream.read(reinterpret_cast<char*>(&item_subject_len), sizeof(size_t));
		char* item_subject = new char [item_subject_len + 1];
		file_stream.read(item_subject, item_subject_len);
		item_subject[item_subject_len] = '\0';
		std::string item_string(item_subject);
		m_subjects.push_back(item_string);
		delete [] item_subject;
	}

	file_stream.close();

	return true;
}

bool HomeworkManager::delete_item(const unsigned short& id)
{
	std::vector<work_entry>::iterator it = m_works.begin() + (id - 1);
    m_works.erase(it);
	return true;
}

Wenn ich nen Fehler drin hab müsst ihr bescheid sagen ... Version 1.0 ...

Edit
Hatte bei der Show items einen Fehler drin und hab dir die delete Funktion noch hinzugefügt ... achja und bei der Ausgabe von allen Items auch direkt noch die ID mit ausgeben lassen, damit der Benutzer auch weiß was er für Nummern bei show item und delete item angeben muss ...