Подскажите как это лучше сделать. До этого я пользовался глобальными переменными, но их количество быстро растет и запутывает код. Есть ли способ лучше?

Я использовал класс CDocument когда мне надо было хранить данные, и получать доступ несколькими классами..
Это для MFC

Вообщето все зависит от задачи. Подробнее плз.

Nuzur
Можно организовать диспетчер сообщений. Объекты кладут сообщения(события и т.п.) в какую-нить очередь. Диспетчер - распределяет сообщения, кому какое сообщение предназначается.

Код

До этого я пользовался глобальными переменными, но их количество быстро растет и запутывает код.

объединяйте переменные в структуры по определенным признаком, будет по проще

можно создавать свой клас данных или как было замечено (СDOCUMENT) и в каждый клас передавать указатель на класс данных....

и как правильно сказали - все зависит от задачи и от порядка взаимодействия классов....

Например есть класс который занимаеться мат операциями с содержимым файла.
Другой класс занимаеться всяческой "анимацтонной работой".
Третий выполняет вспомогательные функции между ними.
И они все между собой взаимодействуют, передают имена следующих файлов, нрмера ячеек, у и всякую фигню.
У меня уже около 20-ти глобальных....и я боюсь что сегодня их станет 30-ть
В структуры обдинять дело неблагодарное, поскольку "они" разные и для разных функций.
А что там с диспетчером, можно попдробней, и особенно на том моменте как ЭТО ДОЛЖНО помочь, я если честно не совсем понимаю
Добавлено @ 18:16
Да еще, обьединять эти 3-ри класса нельзя, поскольку так или иначе они входят, точнее используються, другими, и если их начать обьединять то будет 1-н модуль.
Это следствие не неправильной планировки, а специфики решаемой задачи

Цитата

Да еще, обьединять эти 3-ри класса нельзя, поскольку так или иначе они входят, точнее используються, другими, и если их начать обьединять то будет 1-н модуль.

А что-нить общее их объяденяет? Я имею ввиду тип сообщениями и т.п.
Самое простое это сделать абстрактный базовый класс. В котором будет функция типа virtual BOOL ProcessMessage(const cMessage&) = 0;
Если по сложнее, то можно организовать класс типа CUniversalMessage. Это будет очень мощный класс. В который можно будет добавлять поля. Короче динамическое сообщение, в которое можно будет "на ходу" добавлять поля с данными. Естественнго реализация такого сообщения и диспетчера займет много времени.

Делать было не чего, время было темное.
Пример, что такое диспетчер сообщений. Такой простенький и юзающий STL.
Наврядли подойдет. Т.к. классы используют один тип сообщения. Хотя сообщение можно настроить. Передавать поинтеры например.
TSTBase.h

Код

#ifndef __TST_BASE__ #define __TST_BASE__ #pragma warning(disable:4786) // 'identifier' : identifier was truncated to 'number' characters in the debug information #include "windows.h" #include <algorithm> #include "TSTConst.h" namespace tst{  typedef DWORD TYPEOBJECT;  typedef DWORD NUMOBJECT;  typedef std::pair<TYPEOBJECT,NUMOBJECT> IDOBJECT; } //namespace tst #endif  //__TST_BASE__

TSTMessage.h

Код

#ifndef __TST_MESSAGE__ #define __TST_MESSAGE__ #include "TSTBase.h" namespace tst{  struct cMessage {    DWORD m_wObjType;    DWORD m_wObjId;    DWORD m_dwEvent;    DWORD m_dwParm;    DWORD m_dwParm1;    WORD  m_wBackupPortID;  };    typedef std::pair<IDOBJECT,cMessage> MESSAGE; } //namespace tst #endif  //__TST_MESSAGE__

TSTObject.h

Код

#ifndef __TST_OJECT__ #define __TST_OJECT__ #include "TSTMessage.h" #include <map>            // STL! namespace tst{  class cDispatcher;  /************************************************************************/  /* class cObject                                                        */  /************************************************************************/  class cObject  {    typedef cObject* POBJECT;    typedef std::map<IDOBJECT,POBJECT> OBJECTCONTAINER;    friend class cDispatcher;    public:                  cObject(const TYPEOBJECT& TypeObj, const NUMOBJECT& IdObj);      virtual ~   cObject();                    TYPEOBJECT  GetType() const { return m_ID.first; }              NUMOBJECT   GetNum() const { return m_ID.second; }              IDOBJECT    GetID() const { return m_ID; }      virtual BOOL        ProcessMessage(const cMessage&)  = 0;          protected:      IDOBJECT m_ID;    private:      static OBJECTCONTAINER m_ObjConatiner;    }; } //namespace tst #endif  //__TST_OJECT__

TSTObject.cpp

Код

#include "TSTOBJECT.H" using namespace tst; cObject::OBJECTCONTAINER cObject::m_ObjConatiner; /************************************************************************/ /* FUNCTION    : cObject( const TYPEOBJECT& TypeObj,                    */ /*                        const NUMOBJECT&  IdObj)                      */ /* OBJECT      : cObject                                                */ /* PURPOSE     : Constructor                                            */ /* PARAMETERS  : TypeObj - Type of object                               */ /*               NUMOBJECT - unique number of object                    */ /* RETURN VALUE: none                                                   */ /* COMMENT     : none                                                   */ /************************************************************************/ cObject::cObject(const TYPEOBJECT& TypeObj, const NUMOBJECT& IdObj): m_ID(std::make_pair(TypeObj,IdObj)) {  m_ID=std::make_pair(TypeObj,IdObj);  if ( cObject::m_ObjConatiner.find(m_ID) != cObject::m_ObjConatiner.end() )  // ELEM EXIST  {    //std::out_of_range("Elem exist");  }  else    cObject::m_ObjConatiner.insert( OBJECTCONTAINER::value_type(m_ID, this) ); } /************************************************************************/ /* FUNCTION    : ~cObject()                                             */ /* OBJECT      : cObject                                                */ /* PURPOSE     : Destructor                                             */ /* PARAMETERS  : none                                                   */ /* RETURN VALUE: none                                                   */ /* COMMENT     : none                                                   */ /************************************************************************/ cObject::~cObject() {  OBJECTCONTAINER::iterator i= cObject::m_ObjConatiner.find(m_ID);  if ( i !=  cObject::m_ObjConatiner.end() )                                  // ELEM EXIST    cObject::m_ObjConatiner.erase(i);  else    throw ("BRED");   // CRITICAL !!! }

TSTDispatch.h

Код

#ifndef __TST_DISPATCH__ #define __TST_DISPATCH__ #include <queue>        // STL! #include "TSTMessage.h" namespace tst{  void  InitDispatcher();                                         // prototype  void  DeInitDispatcher();                                       // prototype  void  Dispatch();                                               // prototype  void  PutMessageMain(const IDOBJECT& Id, const cMessage& Msg);  // prototype  void  PutMessageMain(const MESSAGE& Msg);                       // prototype  /************************************************************************/  /*  cDispatcher                                                         */  /************************************************************************/  class cDispatcher  {    typedef std::queue<MESSAGE> QUEUE;    friend  void  InitDispatcher();    friend  void  DeInitDispatcher();    friend  void  Dispatch();    friend  void  PutMessageMain(const IDOBJECT& Id, const cMessage& Msg);    friend  void  PutMessageMain(const MESSAGE& Msg);                        void  PutMessageMain(const IDOBJECT& Id, const cMessage& Msg);            void  PutMessageMain(const MESSAGE& Msg);        cDispatcher() { cDispatcher::m_pDispatcher=this; }      ~ cDispatcher() { cDispatcher::m_pDispatcher=NULL; }        cDispatcher(const cDispatcher&);      static cDispatcher*  m_pDispatcher;      QUEUE m_MainQueue;      void Dispatch();    }; } //namespace tst #endif  //__TST_DISPATCH__

TSTDispatch.cpp

Код

#include "TSTDISPATCH.H" #include "TSTObject.h" using namespace tst; cDispatcher* cDispatcher::m_pDispatcher=NULL; /************************************************************************/ /* FUNCTION    : InitDispatcher()                                       */ /* OBJECT      : none                                                   */ /* PURPOSE     : Initialization of dispatcher                           */ /* PARAMETERS  : none                                                   */ /* RETURN VALUE: none                                                   */ /* COMMENT     : none                                                   */ /************************************************************************/ void tst::InitDispatcher() {  if ( !cDispatcher::m_pDispatcher )  new cDispatcher(); } /************************************************************************/ /* FUNCTION    : DeInitDispatcher()                                     */ /* OBJECT      : none                                                   */ /* PURPOSE     : Deinitialization of dispatcher                         */ /* PARAMETERS  : none                                                   */ /* RETURN VALUE: none                                                   */ /* COMMENT     : none                                                   */ /************************************************************************/ void tst::DeInitDispatcher() {  if ( cDispatcher::m_pDispatcher ) delete cDispatcher::m_pDispatcher; } /************************************************************************/ /* FUNCTION    : Dispatch()                                             */ /* OBJECT      : none                                                   */ /* PURPOSE     : Message dispatch                                       */ /* PARAMETERS  : none                                                   */ /* RETURN VALUE: none                                                   */ /* COMMENT     : none                                                   */ /************************************************************************/ void tst::Dispatch() {  cDispatcher::m_pDispatcher->Dispatch(); } /************************************************************************/ /* FUNCTION    : PutMessageMain(const IDOBJECT& Id, const cMessage& Msg)*/ /* OBJECT      : none                                                   */ /* PURPOSE     : To put message to main queue                           */ /* PARAMETERS  : Id - id of object                                      */ /*               Msg - message                                          */ /* RETURN VALUE: none                                                   */ /* COMMENT     : none                                                   */ /************************************************************************/ void tst::PutMessageMain(const IDOBJECT& Id, const cMessage& Msg) {  cDispatcher::m_pDispatcher->PutMessageMain(Id,Msg); } /************************************************************************/ /* FUNCTION    : PutMessageMain(const MESSAGE& Msg)                     */ /* OBJECT      : none                                                   */ /* PURPOSE     : To put message to main queue                           */ /* PARAMETERS  : Msg - message                                          */ /* RETURN VALUE: none                                                   */ /* COMMENT     : none                                                   */ /************************************************************************/ void tst::PutMessageMain(const MESSAGE& Msg) {  cDispatcher::m_pDispatcher->PutMessageMain(Msg); } /************************************************************************/ /* FUNCTION    : Dispatch()                                             */ /* OBJECT      : cDispatcher                                            */ /* PURPOSE     : Message dispatch                                       */ /* PARAMETERS  : none                                                   */ /* RETURN VALUE: none                                                   */ /* COMMENT     : none                                                   */ /************************************************************************/ void cDispatcher::Dispatch() {  while ( !m_MainQueue.empty() )  {    cObject::OBJECTCONTAINER::iterator i=cObject::m_ObjConatiner.find( m_MainQueue.front().first );    if ( i!=cObject::m_ObjConatiner.end() )      i->second->ProcessMessage(m_MainQueue.front().second);    m_MainQueue.pop();  } } /************************************************************************/ /* FUNCTION    : PutMessageMain(const IDOBJECT& Id, const cMessage& Msg)*/ /* OBJECT      : cDispatcher                                            */ /* PURPOSE     : To put message to main queue                           */ /* PARAMETERS  : Id - id of object                                      */ /*               Msg - message                                          */ /* RETURN VALUE: none                                                   */ /* COMMENT     : none                                                   */ /************************************************************************/ void cDispatcher::PutMessageMain(const IDOBJECT& Id, const cMessage& Msg) {  m_MainQueue.push( std::make_pair( Id, Msg) ); } /************************************************************************/ /* FUNCTION    : PutMessageMain(const MESSAGE& Msg)                     */ /* OBJECT      : cDispatcher                                            */ /* PURPOSE     : To put message to main queue                           */ /* PARAMETERS  : Msg - message                                          */ /* RETURN VALUE: none                                                   */ /* COMMENT     : none                                                   */ /************************************************************************/ void cDispatcher::PutMessageMain(const MESSAGE& Msg) {  m_MainQueue.push(Msg); }

TSTTimer.h

Код

#ifndef __TST_TIMER__ #define __TST_TIMER__ #include "TSTObject.h" #include <list>           // STL! namespace tst{  void      InitTimers();                                                               // prototype  void      DeInitTimers();                                                             // prototype  void      ProcessTimers();                                                            // prototype  IDOBJECT  StartTimer(const DWORD& Interval, const IDOBJECT& Id, const cMessage& Msg); // prototype  BOOL      StopTimer (const IDOBJECT& Id);                                             // prototype  class cTimerContainer;  /************************************************************************/  /*  cTimer                                                              */  /************************************************************************/  class cTimer: public cObject  {    friend cTimerContainer;  public:              cTimer();    virtual ~ cTimer(){};    virtual BOOL  ProcessMessage(const cMessage&) { return TRUE; }            MESSAGE   m_Message;            DWORD     m_dwInterval;            DWORD     m_dwExpirationTime;    static  NUMOBJECT m_Next;  };  /************************************************************************/  /*  cTimerContainer                                                     */  /************************************************************************/  class cTimerContainer  {    typedef std::list<cTimer*> CONTAINER;    friend  void      InitTimers();    friend  void      DeInitTimers();    friend  void      ProcessTimers();    friend  IDOBJECT  StartTimer(const DWORD& Interval, const IDOBJECT& Id, const cMessage& Msg);    friend  BOOL      StopTimer (const IDOBJECT& Id);    class FindTimeOut   // predicate   {      public:    FindTimeOut(const DWORD& Time):m_Time(Time){}    bool operator()(const cTimer *timer1) const;      DWORD m_Time;    };  public:    IDOBJECT  StartTimer(const DWORD& Interval, const IDOBJECT& Id, const cMessage& Msg);    BOOL      StopTimer (const IDOBJECT& Id);    void      Process();  protected:  private:    cTimerContainer();    ~cTimerContainer();    static cTimerContainer* m_pTimerContainer;    void  NormalizeTimers(const DWORD& dwValue);    CONTAINER m_ListTimers;    DWORD     m_CountActiveTimer;    DWORD     m_dwLastAccess;  }; } //namespace tst

TSTTimer.cpp

Код

#include "TSTTimer.h" #include "TSTDispatch.h" #include <algorithm>      // STL! using namespace tst; NUMOBJECT        cTimer::m_Next                     = NULL; cTimerContainer* cTimerContainer::m_pTimerContainer = NULL; /************************************************************************/ /* FUNCTION    : cTimer                                                 */ /* OBJECT      : cTimer                                                 */ /* PURPOSE     : Constructor                                            */ /* PARAMETERS  : none                                                   */ /* RETURN VALUE: none                                                   */ /* COMMENT     : none                                                   */ /************************************************************************/ cTimer::cTimer(): cObject(TST_OBJ_TIMER,m_Next) {  ++m_Next;   // Next number of timer object } /************************************************************************/ /* FUNCTION    : InitTimers()                                           */ /* OBJECT      : none                                                   */ /* PURPOSE     : Initialization of class cTimerContainer                */ /* PARAMETERS  : none                                                   */ /* RETURN VALUE: none                                                   */ /* COMMENT     : none                                                   */ /************************************************************************/ void tst::InitTimers() {  if ( !cTimerContainer::m_pTimerContainer ) new cTimerContainer(); } /************************************************************************/ /* FUNCTION    : DeInitTimers()                                         */ /* OBJECT      : none                                                   */ /* PURPOSE     : DeInitialization of class cTimerContainer              */ /* PARAMETERS  : none                                                   */ /* RETURN VALUE: none                                                   */ /* COMMENT     : none                                                   */ /************************************************************************/ void tst::DeInitTimers() {  if ( cTimerContainer::m_pTimerContainer ) delete cTimerContainer::m_pTimerContainer; } IDOBJECT  tst::StartTimer(const DWORD& Interval, const IDOBJECT& Id, const cMessage& Msg) {  return cTimerContainer::m_pTimerContainer->StartTimer(Interval,Id,Msg); } BOOL  tst::StopTimer (const IDOBJECT& Id) {  return cTimerContainer::m_pTimerContainer->StopTimer(Id); } void tst::ProcessTimers() {  cTimerContainer::m_pTimerContainer->Process(); } cTimerContainer::cTimerContainer():m_CountActiveTimer(0UL) {  m_pTimerContainer=this;  m_dwLastAccess=GetTickCount(); } cTimerContainer::~cTimerContainer() {  for ( CONTAINER::iterator i=m_ListTimers.begin(); i!=m_ListTimers.end(); ++i )  {    delete (*i);    --m_CountActiveTimer;  }  m_ListTimers.clear();  m_pTimerContainer=0; } IDOBJECT cTimerContainer::StartTimer(const DWORD& Interval, const IDOBJECT& Id, const cMessage& Msg) {  cTimer* Temp= new cTimer();  Temp->m_Message=std::make_pair(Id,Msg);  Temp->m_dwExpirationTime = GetTickCount()+Interval;  m_ListTimers.push_back( Temp );  ++m_CountActiveTimer;  return Temp->GetID(); } class findID { public:  findID(const IDOBJECT& Id):m_ID(Id){}  bool operator()(const cTimer *timer1)  {    return timer1->GetID() == m_ID;  }  IDOBJECT m_ID; }; BOOL cTimerContainer::StopTimer(const IDOBJECT& Id) {  CONTAINER::iterator i = std::find_if( m_ListTimers.begin(),m_ListTimers.end(),findID(Id) );  if ( i!=m_ListTimers.end() )  {    m_ListTimers.erase(i);    delete (*i);    --m_CountActiveTimer;    return TRUE;  }  return FALSE; } bool cTimerContainer::FindTimeOut::operator()(const cTimer *timer1) const {  if ( timer1->m_dwExpirationTime <= m_Time )    PutMessageMain(timer1->m_Message);  return timer1->m_dwExpirationTime <= m_Time; } void cTimerContainer::Process() {  DWORD dwTime=GetTickCount();  if(dwTime < m_dwLastAccess) NormalizeTimers(m_dwLastAccess);  m_dwLastAccess=dwTime;  m_ListTimers.remove_if( FindTimeOut(dwTime) ); } void cTimerContainer::NormalizeTimers(const DWORD& dwValue) {  for ( CONTAINER::iterator i=m_ListTimers.begin(); i!=m_ListTimers.end(); ++i )    (*i)->m_dwExpirationTime -= dwValue; }

А вот его использование:
MAIN.CPP

Код

#include "TSTDispatch.h" #include "TSTTimer.h" #define TST_OBJ_TEST 0x100 class cTest:public tst::cObject { public:  cTest():cObject(TST_OBJ_TEST,m_Next)  {    ++m_Next;  }  ~cTest(){}  BOOL ProcessMessage(const tst::cMessage& Msg)  {    printf("\nProcessMessage:");    printf("\n  TYPEOBJECT = %08X",GetType());    printf("\n  NUMOBJECT  = %08X",GetNum());    return TRUE;  }  tst::IDOBJECT StartTimer(DWORD Int)  {    tst::cMessage Msg;    return tst::StartTimer(Int,GetID(),Msg);  } protected: private:  static tst::NUMOBJECT m_Next; }; tst::NUMOBJECT cTest::m_Next=0; int main(int argc, char* argv[]) { printf("Hello World!\n");  tst::InitDispatcher();  tst::InitTimers();  cTest Test;  Test.StartTimer(1000);  Test.StartTimer(1500);  Test.StartTimer(2000);  while (true) {    tst::ProcessTimers();    tst::Dispatch();  } return 0; }

Этот простенький примерчик посылает сообщения другим объектам по таймеру. Т.е. один объект посылает сообщение другому объекту. Этот другой принимает сообщение через определенное время. В общем реальный диспетчер

З.Ы.: Народ! По-критикуйте плиз Буду очень благодарен за критику.