U
Ich hatte dann doch ein wenig lange Weile:
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
