3. Hausaufgaben Verwaltungs Programm

Hausaufgaben Verwaltungs Programm

  • *

    hmm`? naja er hat dir da eigentlich mehr so nen pseudocode geliefert ... genau so müssen die Punktionen natürlich nicht aussehen ... aber mal sein Ansatz erklärt:

    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 ...
};
    0
  • I

    Ich hab jetzt den Aufbau so übernommen, jedoch weiß ich nicht wie ich die Funktion einbauen kann, das er die Hausaufgaben einliest, und dann auch am richtigen Wochentag ausgibt, hier mal mein bisheriger Sourcecode:

    #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");
}
    0
  • ?
     

    #include <iostream>
#include <vector>
#include <string>
using namespace std;

struct aufgabe_termin 
{ 
    int Unterrichtsfach;
    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 
    aufgabe_termin mystruct ;              // ... wird Zauberei! 
    void dateneinlesen(); 
    void datensichern(); 
    void sortieren(); 
    void suchen(); 
}; 

void hausaufgaben::eingabe()
{
    char a = 0;

    cout << "Deutsch = 1, Physik = 2 usw." << endl;
    do
    {
        cout << "Bitte Nummer fuer Unterrichtsfach eingeben: " << endl;
        cin  >> mystruct.Unterrichtsfach;
        // Hier wär ne Reaktion auf falsche Eingabe angezeigt
        // Die Eingabefunktion braucht weiterhin Hausaufgabe und timestamp
        // ...
        // ...

        mycontainer.push_back(mystruct);

        cout << "Weitere Hausaufgaben eingeben? J/N" << endl;

        cin >> a;

    }while(a == 'J' || a == 'j');
}

int main() 
{ 

   hausaufgaben my; 

   my.eingabe();

}

    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.

    0
  • I

    Ich benutz den Dev-C++ Compiler und Windows XP,
    ich weiß noch nicht genau wie ich die Eingabe Funktion schreiben soll, da ich noch nicht sehr gut in C++ bin, ich probier aber mal das beste

    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

    0
  • ?

    Iksde schrieb:

    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

    0
  • *
     

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

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 sort(const bool); // ascending

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

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

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));
}

int main()
{
	HomeworkManager manager;

	char a = '\0';

	std::cout << "Deutsch = 1, Physik = 2 usw." << std::endl;
    do
    {
		work_entry entry;
		std::cout << "Bitte Nummer fuer Unterrichtsfach eingeben: " << std::endl;
		std::cin >> entry.subject;
		// usw ...

		manager.insert_item(entry);

		std::cout << "Weitere Hausaufgaben eingeben? J/N" << std::endl;

		std::cin >> a;

    } while(a == 'J' || a == 'j');

	manager.show_item(-1);
}

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

    0
  • *

    so ..

    #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;
		}
	}
}

    😉

    0
  • I

    Ich hab das mal kopier und eingefügt aber bekomm bei

    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
    0
  • ?

    Nimm <sstream> ! 😉

    0
  • ?

    nur oben
    #include <sstream> zusätzlich einfügen!

    0
  • I

    Dankeschön das Programm funktioniert bis jetzt ganz gut, allerdings ist irgendein Fehler drin, da immer wenn ich die Eingegebenen Hausaufgaben anschauen möchte, nur eine Zahl dortsteht wo eigentlich das Fach stehen sollte,
    wenn ich folgenden Code:

    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

    0
  • S

    (D)Evil wenn du schon kein using namespace std; benutzen tust warum machst du dann nicht einfach using std::cout, wenn du nicht den ganzen namensbereich einbinden willst

    0
  • *

    Ja das ist das Problem ... du sollst den Code nicht übernehmen ... nimm ihn einfach als Beispiel ...

    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 ;)
    0
  • I

    Danke, solangsam versteh ich den groben Aufbau des Programmes auch!
    Nun habe ich das Programm auf meinen Stundenplan abgestimmt, und es wird auch nicht mehr die ID, sondern das Fach angezeigt wenn ich mir meine Hausaufgaben anzeigen lasse, nun brauch ich aber noch eine Funktion womit ich die Hausaufgabe als erledigt markieren kann, damit sie aus dem Speicher verschwindet.

    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

    0
  • *

    Ja ich weiß wie man das machen könnte ... also ich hab dir jetzt hier mal eine Speicherfunktion usw. hinzugefügt. Du darfst den Code allerdings nicht kopieren, denn du sollst ihn verstehen!

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

    0
  • I

    Ich werde es nicht kopieren, versprochen!
    Nur könntest du vielleicht ein paar Kommentare hinter dem Sourcecode geben damit ich weiß wo was zu da ist? Ich versteh bis jetzt nämlich fast gar nix!

    0
  • *

    Hmm ja kein Problem ... welche Funktion verstehst du denn nicht? Die zum Speicher/Laden? 😉 Oder welche?

    0
  • I

    Ja, also die Speicher Funktion und die Delete Funktion

    0
  • *

    Na dann ... fangen wir mal an ^^

    bool HomeworkManager::write_file(const std::string& filename)
{
    std::ofstream file_stream; // Das ist ein sog. File-Stream ...
    file_stream.open(filename.c_str(), std::ios::out | std::ios::binary); // Damit öffnen wir die Datei, 
    // die in filename hinterlegt ist und zwar im std::ios::out mode, da wir ja schreiben wollen ... und dann nor std::ios::binary, 
    // da wir es binär schreiben wollen ...

    if (file_stream.is_open() == false || file_stream.good() == false) // Das ist nur Fehlerüberprüfung ob das 
    // Öffnen Funktionier hat ...
        return false;

    // Hier hab ich dir nur aufgeschrieben, wie die Datei strukturiert ist bzw aufgebaut ist.
    // 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(); // Erstmal die Anzahl an Fächern holen
    file_stream.write(reinterpret_cast<char*>(&subject_count), sizeof(size_t)); // Das dann in die Datei schreiben ...
    if (file_stream.good() == false) // Alles ok?
        return false;

    size_t works_count = m_works.size(); // Das selbe für die Anzahl an Hausaufgaben ...
    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) // Alle Hausaufgaben durchgehen ...
    {
        char*    item_work        = const_cast<char*>(m_works[item].work.c_str()); // Da c_str einen const char* zurück gibt ... wir aber nur einen char* 
        // gebrauchen können, müssen wir das const wegcasten ...
        size_t    item_work_len    = m_works[item].work.length(); // Die Länge des Strings holen ... brauchen wir beim
        // Einlesen wieder ...
        file_stream.write(reinterpret_cast<char*>(&m_works[item].timestamp), sizeof(time_t)); // Den Zeitpunkt abspeichern
        file_stream.write(reinterpret_cast<char*>(&item_work_len), sizeof(size_t)); // Jetzt die Länge des Strings reinpacken ...
        file_stream.write(item_work, item_work_len); // den String selbst auch ...
        file_stream.write(reinterpret_cast<char*>(&m_works[item].subject), sizeof(unsigned short)); // und am Ende noch welches Fach es ist ...

        if (file_stream.good() == false) // War das alles erfolgreich?
            return false;
    }

    for (size_t item = 0; item < subject_count; ++item) // Alle Fächer durchgehen
    {
        char*    item_subject        = const_cast<char*>(m_subjects[item].c_str()); // wieder const wegcasten
        size_t    item_subject_len    = m_subjects[item].length(); // die lenge des Fachnamens holen ...
        file_stream.write(reinterpret_cast<char*>(&item_subject_len), sizeof(size_t)); // Rein in die Datei damit ...
        file_stream.write(item_subject, item_subject_len); // und der String selbst kommt hinterher ...
    }

    file_stream.close(); // Den Stream schließen ...

    return true;
}

    So ...

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

    Durch diesen Ansatz bist du unabhängig davon was du wann für Fächer registrierst ... denn am Anfang holt der sich beim Laden erstmal wieder die Fächer mit denen die Hausaufgaben erstellt worden sind ...
    Subject Count und Item Count hab ich mit rein getan, weil die das Auslesen nachher ungemein vereinfachen ... da du so weißt wie Lang dein Hausaufgaben und dein Fächer - Block ist ...
    string_len schreiben wir auch mit rein, da wir ja nicht wissen können, wie lang denn der darauf folgende String wohl sein wird ... weil std::string ja nicht ne feste Größe hat ...

    0
  • I

    Oben ist ja mein jetziger Sourcecode angegeben, und irgendwie merke ich grade das

    #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;
}

    gar nicht mehr auf meinen Aufbaut, hab ich da recht?

    Gruß
    Manuh

    0
Anmelden zum Antworten