Arges Design Problem.

-ManagerManager soll nur 1x existieren, den rest kanns so oft geben wie will.
-Ineinanderverschachtelungen? niemals.
-Im laufe des programms

otze

Ineinanderverschachtelungen? niemals.

dann hats erst recht keinen sinn, ManagerManger von IManager abzuleiten, denn da er nicht selber in einem ManagerManager enthalten sein kann, kann er auch kein manager sein.

dann würde ich auch pontos version ohne vorbehalt benutzen, ansonsten würde ich mir nen umweg suchen^^

okay lassen wir innenverschachtelungen doch zu, okay?

otze

deine meinungen schwenken ja fast so wie eine fahne im wind

kommen wir mal zum punkt: wieso muss managermanager ein Imanager sein? er soll wie dus vorhin gesagt hast nicht verschachtelt werden können, für einen manager dieses typs ist das ok, sowas würd ich wahrscheinlich auch als singleton iplementieren.

es ist klar, ManagerManager managed irgendwas, aber ansonsten hat er mit den anderen von dir genannten managern nicht viel am hut,ich würde sogar weiter gehen, und sagen, dass es sogar schädlich ist, den managermanager wie alle andere manager zu betrachten. gibts irgendeine funktion, der du den ManagerManager so übergeben können musst wie alle anderen manager auch? wenn nicht, dann musst du ihn nicht zwanghaft von irgendeinem interface ableiten.

google mal nach factory pattern.

Hi,

nochwas:

ich wollte nun die get-methode so umformen das ne schleife drin ist:

template <typename T> T & get_manager() 
     { 
        for (unsigned int i=0; i<managers_.size(); ++i) 
            if (managers_[i]->typ == T::typ)
                return (T&) *managers_[i]; 
     }

die bringt nur nen absturz wieso?

Ponto

--- schrieb:

Hi,

nochwas:

ich wollte nun die get-methode so umformen das ne schleife drin ist:
template <typename T> T & get_manager() 
     { 
        for (unsigned int i=0; i<managers_.size(); ++i) 
            if (managers_[i]->typ == T::typ)
                return (T&) *managers_[i]; 
     }
die bringt nur nen absturz wieso?

1. Macht add_manager nur ein push_back()? Sollte dann wieder so sein.
2. managers_[i]->typ gibt immer den Typ der Basisklasse, da muss eine virtuelle Funktion hin. managers_[i]->get_typ() und get_typ wird fuer jeden Manager implementiert, indem typ zurückgegeben wird.

nö kein pushback, hab den code genommen den du verändert hast

Ponto

--- schrieb:

nö kein pushback, hab den code genommen den du verändert hast

Der muss da wieder hin. Ich hab den rausgenommen, weil das dann mit dem template einfacher war.

Weiterhin sollte managers_ am anfang wieder 0 elemente und nicht 3 haben.

Hi,

habs nun so gemacht:

template <typename T> void addManager(T *x) 
     { 
         managers_.push_back(x); 
     } 

     void restore (void) 
     { std::cout << "ManagerManager: restore" << std::endl; 
         for (unsigned int i=0; i<managers_.size(); ++i) 
             managers_[i]->restore(); 
     } 

     template <typename T> 
     T & get_manager() 
     { 
      return (T&) *managers_[T::typ]; 
     }

doch ruf ich nun get_manager auf oder restore, schmiert das programm ab? Wieso?

das mit restore hab ich rausgefunden, musste im ManagerManager das managers_ (3) entfernen.

nun streit aber noch immer die get-funktion

hi noch was ist mir aufgefallen:

schreibe ich sowas:
MM.get_manager<BitmapManager>().foo ();

läuft es einwandfrei, jetzt hab ich in BitmapManager jedoch ne Funktion eingebaut welche einen wert der im inner ist verändern soll:

Funktion bar:

class BitmapManager : public IManager 
 { 
 public: 
     BitmapManager    (void) 
     { std::cout << "C'tor BitmapManager" << std::endl; } 
     ~BitmapManager   (void) 
     { std::cout << "D'tor BitmapManager" << std::endl; } 

     void restore (void) 
     { std::cout << "BitmapManager: restore" << std::endl; } 
     void load (void) 
     { std::cout << "BitmapManager: load" << std::endl; } 

      void bar (int i) 
     { std::cout << "BitmapManager: bar" << std::endl; x=i;} 
     void foo (void) 
     { std::cout << "BitmapManager: foo " << x << std::endl; } 

     static int const typ = 1; 

     int x;
 };

ruf ich die bar funktion so auf:
MM.get_manager<BitmapManager>().bar (0190123456);

schmiert alles ab.

Ponto

Hier mal eine Version mit ein paar Variationen:

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

class IManager
{
public:
   IManager() {};
   virtual ~IManager() {};
   virtual int get_type() { return typ; }

   void restore() { do_restore(); }
   void load() { do_load(); }

   static int const typ = 0;

protected:
   virtual void    do_restore () = 0;
   virtual void    do_load    () = 0;
};

class BitmapManager : public IManager
{
public:
   BitmapManager() {}
   ~BitmapManager() {}
   virtual int get_type() { return typ; }

   void foo() { std::cout << "foo" << std::endl; }

   static int const typ = 1;
protected:
   void do_restore() { std::cout << "BM restore" << std::endl; }
   void do_load() { std::cout << "BM load" << std::endl; }
};

class WaveManager : public IManager
{
public:
   WaveManager() {}
   ~WaveManager() {}
   virtual int get_type() { return typ; }

   void bar() { std::cout << "bar" << std::endl; }

   static int const typ = 2;
protected:
   void do_restore() { std::cout << "WM restore" << std::endl; }
   void do_load() { std::cout << "WM load" << std::endl; }
};

class ManagerManager : public IManager
{
public:
   ManagerManager() {}
   ~ManagerManager() {}
   virtual int get_type() { return typ; }

   template <typename T> T * get_manager() {
      for (std::vector<IManager *>::iterator i = managers_.begin(); i != managers_.end(); ++i)
         if ((*i)->get_type() == T::typ)
            return static_cast<T *>(*i);
      return 0;
   }

   void addManager(IManager & manager) {
         managers_.push_back(&manager);
   }

   static int const typ = 3;

protected:
   void do_restore() {std::for_each(managers_.begin(), managers_.end(), std::mem_fun(&IManager::restore)); }
   void do_load() {std::for_each(managers_.begin(), managers_.end(), std::mem_fun(&IManager::load)); }

private:
   std::vector <IManager*> managers_;
};

int main (void) {
   ManagerManager MM;
   BitmapManager BM;
   WaveManager WM;

   MM.addManager(BM);
   MM.addManager(WM);

   MM.load();
   MM.restore();

   MM.get_manager<BitmapManager>()->foo();
   if (MM.get_manager<ManagerManager>() == 0) std::cout << "0 is correct" << std::endl;
   std::cin.get();
}

Hi,

okay, aber wieso klappt das mit der variable setzen nicht?

Ponto

--- schrieb:

Hi,

okay, aber wieso klappt das mit der variable setzen nicht?

Bei meiner letzten Version klappt dies. Ich weiß nicht, was du inzwischen hast.

hi

hier meine version:
[cpp#include <iostream>
#include <string>
#include <vector>

class IManager
{
public:
IManager (void)
{ std::cout << "C'tor IManager" << std::endl; }
virtual ~IManager (void)
{ std::cout << "D'tor IManager" << std::endl; }

virtual void restore (void) = 0;
virtual void load (void) = 0;

static int const typ = 0;
};

class BitmapManager : public IManager
{
public:
BitmapManager (void)
{ std::cout << "C'tor BitmapManager" << std::endl; }
~BitmapManager (void)
{ std::cout << "D'tor BitmapManager" << std::endl; }

void restore (void)
{ std::cout << "BitmapManager: restore" << std::endl; }
void load (void)
{ std::cout << "BitmapManager: load" << std::endl; }

void bar (int i)
{ std::cout << "BitmapManager: bar" << std::endl; x=i;}
void foo (void)
{ std::cout << "BitmapManager: foo " << x << std::endl; }

static int const typ = 1;

int x;
};

class WaveManager : public IManager
{
public:
WaveManager (void)
{ std::cout << "C'tor WaveManager" << std::endl; }
~WaveManager (void)
{ std::cout << "D'tor WaveManager" << std::endl; }

void restore (void)
{ std::cout << "WaveManager: restore" << std::endl; }
void load (void)
{ std::cout << "WaveManager: load" << std::endl; }

void bar (void)
{ std::cout << "WaveManager: bar" << std::endl; }

static int const typ = 2;
};

class ManagerManager
{
public:
ManagerManager (void)
{ std::cout << "C'tor ManagerManager" << std::endl; }
~ManagerManager (void)
{ std::cout << "D'tor ManagerManager" << std::endl; }

void restore (void)
{ std::cout << "ManagerManager: restore" << std::endl;
for (unsigned int i=0; i<managers_.size(); ++i)
managers_[i]->restore();
}
void load (void)
{ std::cout << "ManagerManager: load" << std::endl;
for (unsigned int i=0; i<managers_.size(); ++i)
managers_[i]->load();
}

template <typename T>
T & get_manager()
{
for (unsigned int i=0; i<managers_.size(); ++i)
if (managers_[i]->typ == T::typ)
return (T&) *managers_[i];
}

template <typename T> void addManager(T *x)
{
managers_.push_back(x);
}

private:
std::vector <IManager*> managers_;
};

int main (void)
{

ManagerManager MM;
BitmapManager BM;
WaveManager WM;

MM.addManager (&BM);

MM.restore ();

MM.get_manager<BitmapManager>().bar (9451); // ABSTURZ

MM.get_manager<BitmapManager>().foo ();

std::cin.get();
}[/cpp]

Ponto

Dir fehlt die get_type() Methode und ihr Aufruf.

danke sehr