wxDev.fr, le portail francophone consacré à wxWidgets ! ( The french portal for wxWidgets )  
Esp. membre
Recheche rapide



Recherche avancée
Statistiques
Membres inscrits :2359

Membres en ligne : 0
Invités en ligne : 3

Valid XHTML 1.0 Transitional

Valid CSS2

Menu forum (navigation):
Pages: 1  
 
Accueil » Accueil forums » Développement C/C++
» appel d'une fonction static d'une autre classe, dans la liste d'initia
Conversation : appel d'une fonction static d'une autre classe, dans la liste d'initia
28-05-2008 21:30:00  appel d'une fonction static d'une autre classe, dans la liste d'initia #1
Gandi (Gourou de la secte)
Lieu: Clermont-Ferrand
Inscrit le : 10-10-2007
Messages: 214
Snippets: 5
Tutoriels: 0
Site web
Hors ligne
appel d'une fonction static d'une autre classe, dans la liste d'initialisation d'une classe.

Je m'explique.
J'ai un singleton qui s'occupe de retourner un panel selon le nom d'une classe.

Actuellement pour enregistré cette association je le fais dans le cpp du manager (le singleton) :

Code wxWidgets:

void GR_FrameItem_Manager::InitRegisterPanelAbstractItem()
{
    m_RegisterPanel[wxT("GR_AbstractItem")     ].Add( wxT("GR_PanelItem")  ) ;
    m_RegisterPanel[wxT("GR_Langue_Traitement")].Add( wxT("GR_Panel_Langue_Traitement")  ) ;
    m_RegisterPanel[wxT("GR_Langue_Regle")     ].Add( wxT("GR_Panel_Langue_Traitement")  ) ;
    m_RegisterPanel[wxT("GR_Langue")           ].Add( wxT("GR_Panel_Langue_Traitement")  ) ;
    m_RegisterPanel[wxT("GR_Objet3D")          ].Add( wxT("GR_Panel_Objet3D")  ) ;
}


Ce qui ne me va pas pour deux raisons :
-c'est pas pratique faut allé trouver le panel item manager et si je n'utilise plus certains panels et/ou certains objets il me faudra alors virer quelques lignes.
-l'application est censée à terme avoir des DLL qui se grefferont à elle, et par conséquence d'avoir des fonctionnalités supplémentaires. Hors il n'est pas question de recompiler le code principale.

Alors dans le CPP du panel d'un dérivé de item, juste après #include "GR_StaticMeshe.h"
j'ai essayé différentes tournures, mais rien n'y fait j'arrive pas à ajouter cette association.

Code wxWidgets:

GR_FrameItem_Manager::GetInstance()->RegisterPanelAbstractItem( wxT("GR_Panel_StaticMeshe"), wxT("GR_StaticMeshe")  ) ;


Gemr\GR_StaticMeshe.cpp:5: error: expected constructor, destructor, or type conversion before '->' token
Gemr\GR_StaticMeshe.cpp:5: error: expected `,' or `;' before '->' token


Code wxWidgets:

GR_FrameItem_Manager::RegisterPanelAbstractItem( wxT("GR_Panel_StaticMeshe"), wxT("GR_StaticMeshe")  ) ;

Gemr\GR_StaticMeshe.cpp:6: error: expected constructor, destructor, or type conversion before '(' token
Gemr\GR_StaticMeshe.cpp:6: error: expected `,' or `;' before '(' token



Code wxWidgets:

HashMapwxStringwxArrayString GR_FrameItem_Manager::m_RegisterPanel[wxT("GR_Panel_StaticMeshe")] = wxT("GR_StaticMeshe") ;

HashMapwxStringwxArrayString Gemr\GR_StaticMeshe.cpp:7: error: size of array `m_RegisterPanel' has non-integral type `const char[21]'
Gemr\GR_StaticMeshe.cpp:7: error: conflicting declaration 'HashMapwxStringwxArrayString GR_FrameItem_Manager::m_RegisterPanel[1]'
Gemr\/GR_FrameItem_Manager.h:88: error: 'GR_FrameItem_Manager::m_RegisterPanel' has a previous declaration as `HashMapwxStringwxArrayString GR_FrameItem_Manager::m_RegisterPanel'
Gemr\GR_StaticMeshe.cpp:7: error: conversion from `char[15]' to non-scalar type `HashMapwxStringwxArrayString' requested;


voici les déclarations dans le header du GR_FrameItem_Manager

Code wxWidgets:

        static void RegisterPanelAbstractItem(  wxString aClasseNamePanel, wxString aClasseNameItem )
        {
            m_RegisterPanel[aClasseNameItem].Add( aClasseNamePanel ) ;
        }
 
        static HashMapwxStringwxArrayString m_RegisterPanel ; /*! \brief La Clef est le nom de la classe GR_AbstractItem
                                                               *   et wxArrayString contient les noms des GR_PanelAbstractItem
                                                               *   spécialisé pour cet Item.
                                                               */

Et voici l'initialisation de la hashmap dans le cpp du manager

Code wxWidgets:

#include "GR_FrameItem_Manager.h"
 
HashMapwxStringwxArrayString GR_FrameItem_Manager::m_RegisterPanel ;

----------
http:/brainvisa.info/doc/anatomist/html … bject.html
//le principe de la RTTI , le truc dont j'arrivais pas à comprendre comment y faisait :p .

hop un petit lien intéressant :)
----------
Après avoir lu truc et relu j'avais cru comprendre un truc mais non ça me dit pas comment arrivé à appeler explicitement ou implicitement une fonction statiqueau début de l'exécution .

Dernière modification par Gandi (30-05-2008 23:14:42)


"Les ordinateurs ne remplaceront jamais les livres. Vous ne pouvez pas vous mettre sur une pile de disquettes pour atteindre le haut de votre armoire" ( Sam Ewing )
30-05-2008 23:31:49  Re: appel d'une fonction static d'une autre classe, dans la liste d'initia #2
Xaviou (Administrateur)
Lieu: Annecy (74)
Inscrit le : 27-08-2007
Messages: 1383
Snippets: 25
Tutoriels: 6
Site web
Hors ligne
Salut.

Déjà, première chose : lorsque tu comptes passer des wxString en paramètre d'une fonction/méthode, sous la forme wxT("......"), mets ces paramètres comme étant des const wxString &, ça évitera les problèmes.

Ensuite, est-ce que la méthode "GetInstance" est bien statique elle aussi ?
Dans le cas d'un singleton, elle qui devrait l'être (et pour faire "plus propre", elle devrait retourner une référence plutôt qu'un pointeur, mais ça, c'est pas très important).

Sinon, mets au moins le header complet, parce que là, on j'ai du mal à cerner le truc (mets aussi le cpp, en virant le contenu des fonctions qui ne concernent pas ton problème).

@+
Xav'

Le nouveau portail wxWidgets francophone : www.wxdev.fr
Ben en fait, vous y êtes déjà...
31-05-2008 00:03:53  Re: appel d'une fonction static d'une autre classe, dans la liste d'initia #3
Gandi (Gourou de la secte)
Lieu: Clermont-Ferrand
Inscrit le : 10-10-2007
Messages: 214
Snippets: 5
Tutoriels: 0
Site web
Hors ligne
Le manager qui s'occupe de renvoyer une frame en fonction du nom d'un objet

LE HEADER DU MANAGER DE FRAME :

Code wxWidgets:

#ifndef GR_FRAMEITEM_MANAGER_H
#define GR_FRAMEITEM_MANAGER_H
 
/*!
* \file GR_FrameItem_Manager.h
* \brief Manager des Frames des GR_AbstractItem
* \author Gandi
* \version  0.1
*/

 
#include "wx/wxprec.h"
 
#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif
 
//Gemr
#include "GR_Item.h"
#include "GR_Singleton.h"
 
// pas besoin de gérer pour les parents ( les frame) si elles doivent se delete le panel peut dire si je suis le seul enfant alors je delete le parent
class GR_PanelAbstractItem : public wxPanel, public GR_Observeur
{
    DECLARE_ABSTRACT_CLASS(GR_PanelAbstractItem)
 
    public:
        GR_PanelAbstractItem() ;
        virtual ~GR_PanelAbstractItem();
 
        bool CreatePanelItem( GR_AbstractItem* aItem, wxWindow* parent, const wxPoint& pos, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL ) ;
        bool CreatePanelItem( GR_AbstractItem* aItem, wxWindow* parent ) { return CreatePanelItem( aItem, parent, GetPosition(), GetSize()  ) ; }
        virtual wxString GetClasseNameAbstractItem()=0 ;
        virtual void Refresh( bool eraseBackground = true, const wxRect *rect = (const wxRect *) NULL ) ;
        void Update( int awxClef ) ;
        virtual void SuppressionObservable( int awxClef )=0 ;
 
    protected:
        GR_AbstractItem* m_Item ;
 
        virtual bool CreateInterface()=0 ;/*! C'est dans cette fonction que les enfants construirons leur interface*/
 
    private:
 
};
 
class GR_FrameMere : public wxFrame /*! Cette frame est conçu pour le GR_FrameItem_Manager afin d'avoir une frame parente pour toute l'application */
{
    public:
        GR_FrameMere( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos = wxDefaultPosition, const wxSize& size = wxDefaultSize, long style = wxDEFAULT_FRAME_STYLE, const wxString& name = "FrameMere") ;
        virtual~GR_FrameMere() ;
 
    private:
 
};
 
WX_DECLARE_STRING_HASH_MAP( wxArrayString, HashMapwxStringwxArrayString ) ;
 
class GR_FrameItem_Manager : public GR_Singleton<GR_FrameItem_Manager>
{
    friend class GR_Singleton<GR_FrameItem_Manager>;
 
    public:
 
        GR_PanelAbstractItem* GetPanel( GR_AbstractItem* aItem, wxWindow* parent, const wxPoint& pos, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL ) ;
        wxFrame*              GetFrame( GR_AbstractItem* aItem, wxWindow* parent, const wxPoint& pos, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL ) ;
 
        GR_PanelAbstractItem* GetPanel( GR_AbstractItem* aItem, wxString aItemClasseName, wxWindow* parent, const wxPoint& pos, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL ) ;
        wxFrame*              GetFrame( GR_AbstractItem* aItem, wxString aItemClasseName, wxWindow* parent, const wxPoint& pos, const wxSize& size = wxDefaultSize, long style = wxTAB_TRAVERSAL ) ;
 
        GR_PanelAbstractItem* GetPanel( GR_AbstractItem* aItem, wxWindow* parent = GR_FrameItem_Manager::GetInstance()->GetParent() ) ;
        wxFrame*              GetFrame( GR_AbstractItem* aItem, wxWindow* parent = GR_FrameItem_Manager::GetInstance()->GetParent() ) ;
 
        GR_PanelAbstractItem* GetPanel( GR_AbstractItem* aItem, wxString aItemClasseName, wxWindow* parent = GR_FrameItem_Manager::GetInstance()->GetParent() ) ;
        wxFrame*              GetFrame( GR_AbstractItem* aItem, wxString aItemClasseName, wxWindow* parent = GR_FrameItem_Manager::GetInstance()->GetParent() ) ;
 
 
        wxFrame* GetParent() { return  m_FrameMere ; } //Retourne le parent créé par le manager lors de ça construction et libéré lors de sa destruction.
 
        wxIcon GetIconApplication() { return wxICON(oranthis) ; }
        //wxIcon FrameIcon;
        //FrameIcon.CopyFromBitmap(wxBitmap(wxImage(_T("M:\\_-=Sylgwael=-_\\Programmation\\Gemr CodeBLocks\\Oranthis.ico"))));
 
        static void RegisterPanelAbstractItem(  const wxString& aClasseNamePanel, const wxString& aClasseNameItem )
        {
            m_RegisterPanel[aClasseNameItem].Add( aClasseNamePanel ) ;
        }
 
        static HashMapwxStringwxArrayString m_RegisterPanel ; /*! \brief La Clef est le nom de la classe GR_AbstractItem
                                                               *   et wxArrayString contient les noms des GR_PanelAbstractItem
                                                               *   spécialisé pour cet Item.
                                                               */

 
 
    private:
 
        GR_FrameItem_Manager();
        virtual ~GR_FrameItem_Manager();
 
        void InitRegisterPanelAbstractItem() ;/*! Il Faudra enregistrer en dur vos non de classe dérivant de GR_PanelAbstractItem dans cette fonction t'en que Register Panel ne fonctionne pas. */
 
        wxString FindNamePanel( wxString aItemClasseName ) ; /*! Renvoi le panel le plus adapté à l'Item */
 
        GR_FrameMere* m_FrameMere ; /*! \brief il s'agit d'une frame permettant à n'importe qu'elle window d'avoir
                                    *  un parent qui s'occupe de sa destruction, c'est aussi elle qui enregistre les windows qui ont besoin d'un idle time
                                    */

};
#endif // GR_FRAMEITEM_MANAGER_H

LE CORPS DU MANAGER DE FRAME :

Code wxWidgets:

 
#include "GR_FrameItem_Manager.h"
 
HashMapwxStringwxArrayString GR_FrameItem_Manager::m_RegisterPanel ;
 
///////////////////////////////////////////////////////
 
IMPLEMENT_ABSTRACT_CLASS(GR_PanelAbstractItem, wxPanel)
 
///////////////////////////////////////////////////////
 
GR_PanelAbstractItem::GR_PanelAbstractItem()
{
...
}
///////////////////////////////////////////////////////
 
GR_PanelAbstractItem::~GR_PanelAbstractItem()
{
...
}
///////////////////////////////////////////////////////
 
bool GR_PanelAbstractItem::CreatePanelItem( GR_AbstractItem* aItem, wxWindow* parent, const wxPoint& pos, const wxSize& size, long style )
{
...
}
///////////////////////////////////////////////////////
 
void GR_PanelAbstractItem::Refresh( bool eraseBackground, const wxRect *rect )
{
 
}
///////////////////////////////////////////////////////
 
void GR_PanelAbstractItem::Update( int awxClef )
{
...
}
///////////////////////////////////////////////////////
 
GR_FrameItem_Manager::GR_FrameItem_Manager()
{
    InitRegisterPanelAbstractItem() ;
 
...
}
///////////////////////////////////////////////////////
 
GR_FrameItem_Manager::~GR_FrameItem_Manager()
{
...
}
///////////////////////////////////////////////////////
 
GR_PanelAbstractItem* GR_FrameItem_Manager::GetPanel( GR_AbstractItem* aItem, wxWindow* parent, const wxPoint& pos, const wxSize& size, long style )
{
...
}
///////////////////////////////////////////////////////
 
wxFrame* GR_FrameItem_Manager::GetFrame( GR_AbstractItem* aItem, wxWindow* parent, const wxPoint& pos, const wxSize& size, long style )
{
...
}
///////////////////////////////////////////////////////
 
GR_PanelAbstractItem* GR_FrameItem_Manager::GetPanel( GR_AbstractItem* aItem, wxString aItemClasseName, wxWindow* parent, const wxPoint& pos, const wxSize& size, long style )
{
...
}
///////////////////////////////////////////////////////
 
wxFrame* GR_FrameItem_Manager::GetFrame( GR_AbstractItem* aItem, wxString aItemClasseName, wxWindow* parent, const wxPoint& pos, const wxSize& size, long style )
{
...
}
///////////////////////////////////////////////////////
 
GR_PanelAbstractItem* GR_FrameItem_Manager::GetPanel( GR_AbstractItem* aItem, wxWindow* parent )
{
...
}
///////////////////////////////////////////////////////
 
wxFrame* GR_FrameItem_Manager::GetFrame( GR_AbstractItem* aItem, wxWindow* parent )
{
...
}
///////////////////////////////////////////////////////
 
 
GR_PanelAbstractItem* GR_FrameItem_Manager::GetPanel( GR_AbstractItem* aItem, wxString aItemClasseName, wxWindow* parent )
{
...
}
///////////////////////////////////////////////////////
 
wxFrame* GR_FrameItem_Manager::GetFrame( GR_AbstractItem* aItem, wxString aItemClasseName, wxWindow* parent )
{
...
}
///////////////////////////////////////////////////////
 
void GR_FrameItem_Manager::InitRegisterPanelAbstractItem()
{
// a terme cette fonction doit disparaitre
    m_RegisterPanel[wxT("GR_AbstractItem")     ].Add( wxT("GR_PanelItem")  ) ;
    m_RegisterPanel[wxT("GR_Langue_Traitement")].Add( wxT("GR_Panel_Langue_Traitement")  ) ;
    m_RegisterPanel[wxT("GR_Langue_Regle")     ].Add( wxT("GR_Panel_Langue_Traitement")  ) ;
    m_RegisterPanel[wxT("GR_Langue")           ].Add( wxT("GR_Panel_Langue_Traitement")  ) ;
    m_RegisterPanel[wxT("GR_Objet3D")          ].Add( wxT("GR_Panel_Objet3D")  ) ;
}
///////////////////////////////////////////////////////
 
wxString GR_FrameItem_Manager::FindNamePanel( wxString aItemClasseName )
{
...
}
///////////////////////////////////////////////////////
 
GR_FrameMere::GR_FrameMere( wxWindow* parent, wxWindowID id, const wxString& title, const wxPoint& pos, const wxSize& size, long style, const wxString& name )
: wxFrame( parent, id, title, pos, size, style, name )
{
}
///////////////////////////////////////////////////////
 
GR_FrameMere::~GR_FrameMere()
{
}
///////////////////////////////////////////////////////
 
 


LE HEADER D'UN ITEM ET DE SON INTERFACE :

Code wxWidgets:

 
#ifndef GR_STATICMESHE_H
#define GR_STATICMESHE_H
 
#include "wx/wxprec.h"
 
#ifndef WX_PRECOMP
    #include "wx/wx.h"
#endif
 
// il s'agit d'une meshe dont le maillage n'évolu pas
#include "GR_Meshe.h"
//#include "wx/object.h"
class GR_StaticMeshe : public GR_Meshe
{
    DECLARE_DYNAMIC_CLASS(GR_StaticMeshe)
    public:
        /** Default constructor */
        GR_StaticMeshe();
        /** Default destructor */
        virtual ~GR_StaticMeshe();
 
        virtual void Display() ;
 
// TODO (Gandi#1#): Faire le VBO en indexé
 
        virtual bool Load() ;
        virtual bool UnLoad() ;
 
    protected:
        static const wxString ATT_GL_RenderMode ; // = Mode de Rendu
        static const wxString DEFAUT_VALUES_GL_RenderMode ; // = GL_TRIANGLES
 
        GR_GL_Extensions_Manager * m_ManagerGlExt ; // pour accélérer l'accès
 
        GLuint m_IdVboText ;
        GLuint m_IdVboNorm ;
        GLuint m_IdVboVert ;
 
        bool m_VBOGenere ;
 
    private:
 
};
 
#include "GR_FrameItem_Manager.h"
 
class GR_Panel_StaticMeshe : public GR_PanelAbstractItem
{
    DECLARE_DYNAMIC_CLASS(GR_Panel_StaticMeshe)
    public:
        GR_Panel_StaticMeshe() {}
        virtual ~GR_Panel_StaticMeshe() {}
 
        bool CreateInterface() { return true ; }
        wxString GetClasseNameAbstractItem() { return wxT("GR_StaticMeshe") ; }
        virtual void Refresh( bool eraseBackground = true, const wxRect *rect = (const wxRect *) NULL ) {}
        virtual void SuppressionObservable( int awxClef ) {}
 
 
    protected:
 
    private:
 
        //DECLARE_EVENT_TABLE()
};
 
 
#endif // GR_STATICMESHE_H
 
 



LE COPRS D'UN ITEM ET DE SON INTERFACE :

Code wxWidgets:

#include "GR_StaticMeshe.h"
 
const wxString GR_StaticMeshe::ATT_GL_RenderMode = wxT("Mode de Rendu") ;
const wxString GR_StaticMeshe::DEFAUT_VALUES_GL_RenderMode = wxT("GL_TRIANGLES") ;
//GR_FrameItem_Manager::GetInstance()->RegisterPanelAbstractItem( wxT("GR_Panel_StaticMeshe"), wxT("GR_StaticMeshe")  ) ;
GR_FrameItem_Manager::RegisterPanelAbstractItem( wxT("GR_Panel_StaticMeshe"), wxT("GR_StaticMeshe")  ) ;
//HashMapwxStringwxArrayString GR_FrameItem_Manager::m_RegisterPanel[wxT("GR_Panel_StaticMeshe")] = wxT("GR_StaticMeshe") ;
 
 
IMPLEMENT_DYNAMIC_CLASS (GR_StaticMeshe, GR_Item)
IMPLEMENT_DYNAMIC_CLASS (GR_Panel_StaticMeshe, GR_PanelAbstractItem)
 
GR_StaticMeshe::GR_StaticMeshe()
{
...
}
////////////////////////////////////////////////
 
GR_StaticMeshe::~GR_StaticMeshe()
{
...
}
////////////////////////////////////////////////
 
void GR_StaticMeshe::Display()
{
...
}
////////////////////////////////////////////////
 
bool GR_StaticMeshe::Load()
{
...
}
////////////////////////////////////////////////
 
bool GR_StaticMeshe::UnLoad()
{
...
}
////////////////////////////////////////////////
 


Désolé pour le premier message je voulais évitez d'afficher plein de truc inutile et faciliter la compréhension..c'est raté :p
----------
Bon c'est pas grave, pour les dll je vais faire en sorte d'avoir une fonction à appeler qui ajoutera les nouvelles associations de la DLL.

Dernière modification par Gandi (03-06-2008 13:17:45)


"Les ordinateurs ne remplaceront jamais les livres. Vous ne pouvez pas vous mettre sur une pile de disquettes pour atteindre le haut de votre armoire" ( Sam Ewing )
Menu forum (navigation):
Pages: 1  
 
Accueil » Accueil forums » Développement C/C++
» appel d'une fonction static d'une autre classe, dans la liste d'initia