Arges Design Problem.

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