Sie sollen ein Schlüsselverwaltungsprogramm für eine neu gegründete Firma in C++ realisieren:
Es gibt 2 Arten von Schlüsseln,
• die normalen Zimmerschlüssel schließen nur das jeweilige Zimmer auf ,
• die Abteilungsschlüssel passen auf alle Schlössern einer Abteilung. Die Firma hat die Abteilungen A, B und C.
Jeder Mitarbeiter erhält einen Schlüssel für sein Zimmer, jeder Abteilungsleiter für seine Abteilung. Von den Mitarbeitern wird die Mitarbeiternummer, der Name und die Zimmernummer gespeichert. Vom Abteilungsleiter wird zusätzlich der Name der Abteilung, gespeichert, deren Leiter er ist.
Ihr Programm soll folgende Menüpunkte erhalten:
• Ausgabe eines Schlüssels an einen Mitarbeiter/Abteilungsleiter (Abfrage/Eingabe der Daten über cout/cin)
• Suchen eines Mitarbeiters nach Mitarbeiternummer mit Ausgabe seiner Daten und des an ihn ausgegebenen Schlüssels
• Ausgabe sämtlicher Mitarbeiter, die einen Schlüssel erhalten haben mit Angabe der Schlüsseldaten
• Programmende
Das Programm muss 100 Mitarbeiter und 100 Schlüssel (in Feldern) verwalten können und
mindestens eine Vererbungsbeziehung enthalten.
Die Objekte (nicht die Felder) sollen dynamisch erzeugt werden!
Hinweis:
Ein Feld für dynamisch zu erzeugende Objekte wird wie folgt angelegt:
Mitarbeiter *Mitarbeiterliste[10]; //Array für 10 Instanzen der Klasse Mitarbeiter
Bei Programmstart ist die Datenbank der Schlüsselverwaltung leer. Eine permanente Speicherung der Daten ist nicht gefordert. Die Daten müssen nur zur Laufzeit des Programms verfügbar sein.

Vielen dank für eure Mühe!

Hallo zusammen!
Hab folgende Aufgabenstellung und keinen blassen Dunst! kann mir bitte jemand helfen?

So läuft das hier nicht. Lies dir diesen Thread in Ruhe durch. Ganz wichtig sind die Punkte 1, 2 und 4. Anschliessend kannst du nochmals einen Post erstellen.

logisch wäre X-yyy - also Abteilung und dann eine Zimmernummer - allerdings wäre es auch denkbar, wenn da wirklich nur eine Nummer wäre und die Zuordnung irgendwie anders gelöst wäre...

bb

Da fehlt zwar noch ein Teil(es gehen noch keine Schlüssel auszuteilen), aber ich hab ja auch nicht ewig nix zu tun ;o)
Das das Feld nicht dynamisch erzeugt werden soll, hab ich überlesen

types.h

#pragma once

#include <string>

namespace key_species
{
	enum T
	{
		room,
		section
	};
}

namespace sections
{
	enum T
	{
		A = 0,
		B,
		C
	};

	char names[] =
	{
		'A',
		'B',
		'C'
	};
}

struct room_nr_t
{
	sections::T section;
	unsigned int room_nr;

	room_nr_t(sections::T section, unsigned int room_nr)
	:	section(section), room_nr(room_nr)
	{}
};

bool operator== (const room_nr_t& lhs, const room_nr_t& rhs)
{
	return lhs.section == rhs.section && lhs.room_nr == rhs.room_nr;
}

std::ostream& operator<< (std::ostream& os, const room_nr_t& these)
{
	os << sections::names[these.section] << '-' << these.room_nr;
	return os;
}

typedef unsigned int worker_nr_t;
typedef std::string name_t;
typedef std::string section_name_t;

worker.h

#include "types.h"

#include <iostream>

struct worker_base
{
public:
	worker_base(const name_t& name, const worker_nr_t& nr, const room_nr_t& room)
	: name(name), nr(nr), room(room)
	{}

	virtual void print(std::ostream& os) const = 0;

	virtual ~worker_base() {}

	worker_nr_t get_nr() const
	{
		return nr;
	}
protected:
	worker_nr_t nr;
	room_nr_t room;
	name_t name;
};

std::ostream& operator<< (std::ostream& os, const worker_base& these)
{
	these.print(os);
	return os;
}

struct worker : worker_base
{
public:
	worker(const name_t& name, const worker_nr_t& nr, const room_nr_t& room)
	:	worker_base(name, nr, room),
		key(room)
	{}

	virtual void print (std::ostream& os) const
	{
		os << "Name: " << name << "; Worker number: " << nr << "; Room: " << room;
	}
private:
	key_t<key_species::room> key;
};

struct chief : worker_base
{
public:
	chief(const name_t& name, const worker_nr_t& nr, const room_nr_t& room, const section_name_t& section)
	:	worker_base(name, nr, room),
		section(section),
		key(room.section)
	{}

	virtual void print (std::ostream& os) const
	{
		os << "Name: " << name << "; Worker number: " << nr << "; Room: " << room << "; Section: " << section << "; ";
	}
private:
	section_name_t section;
	key_t<key_species::section> key;
};

key.h

#include "types.h"

template<key_species::T species>
struct key_t;

template< >
struct key_t <key_species::room>
{
public:
	explicit key_t(const room_nr_t& room)
	:	room(room)
	{}

	bool can_open(const room_nr_t& room) const
	{
		return room == this->room;
	}

private:
	room_nr_t room;
};

template< >
struct key_t <key_species::section>
{
public:
	explicit key_t(const sections::T& section)
	:	section(section)
	{}

	bool can_open(const room_nr_t& room) const
	{
		return room.section == section;
	}

private:
	sections::T section;
};

main.cpp

#include <algorithm>
#include <vector>

#include "types.h"
#include "key.h"
#include "worker.h"

int main()
{
	std::vector<worker_base*> all_worker;

	//worker hinzufügen
	all_worker.push_back(new worker("name", 123, room_nr_t(sections::A, 20)));
	all_worker.push_back(new chief ("name", 234, room_nr_t(sections::A, 20), "section"));

	//ausgabe eines schlüssels

	//suchen eines mitarbeiters per nr. -> ausgabe seiner daten + schlüssel
	{
		worker_nr_t x;
		std::cout << "Mitarbeiter Nummer?" << std::endl;
		std::cin >> x;
		for(std::vector<worker_base*>::iterator i(all_worker.begin()), e(all_worker.end()); i != e; ++i)
		{
			worker_base* iter = *i;
			if(iter->get_nr() != x)
				continue;

			std::cout << *iter << std::endl;
			break;
		}
	}

	for(std::vector<worker_base*>::iterator i(all_worker.begin()), e(all_worker.end()); i != e; ++i)
		delete *i;
}

bb