Discussion :

[trecks]

Est-ce qu'une classe peut etre une classe amie d'une classe abstraite?

[Davidbrcz]

L'amitié semble convenir ici.

[trecks]

Oui mais je peux pas faire un friend dans la classe CRenderer pour chaque Manager, parce que ce n'est pas modulaire, sinon à chaque fois que je souhaite ajouter un manager de rendu je suis obligé de rajouter un friend dans la classe CRenderer mais merci quand même

Est-ce que je peux utiliser l'héritage privé c'est à dire que ma classe IManager implémente la méthode Render(laFenêtreCible) en public et les managers héritent de façon privé de cette classe IManager comme ça l'utilisateur n'a pas accès à Render(...) mais par contre dans ma classe CRenderer vu que le vecteur contient des IManager* il pourra lui accéder aux Render des managers par l'intermédiaire de la méthode Render présente en public dans la classe IManager.

Est-ce possible?

[trecks]

Bon finalement j'ai abandonné l'héritage privée. Un bout de code pour vous faire plaisir^^

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
 
#ifndef __IManagerRender_h__
#define __IManagerRender_h__
 
#include <iostream>
#include <SFML/Graphics.hpp>
 
namespace SLE
{
	class IManagerRender
	{
	public:
		IManagerRender(){}
		virtual ~IManagerRender(){}
 
		virtual void RenderToScreen(sf::RenderWindow *pWindow) = 0;
	};
}
 
#endif

Ici RenderToScreen est public et dans ma classe fille il est redéfini en privé

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
 
#ifndef __CSpriteManager_h__
#define __CSpriteManager_h__
 
#include <iostream>
#include <vector>
#include <SFML/Graphics.hpp>
#include "CSingleton.h"
#include "CSprite.h"
#include "IManagerRender.h"
 
namespace SLE
{
	class CSpriteManager : public IManagerRender, public CSingleton<CSpriteManager> 
    {
        friend class CSingleton<CSpriteManager>;
 
    public:
        //Enregistre un sprite
        void RegisterSprite(CSprite *pSprite);
 
        //Supprime un sprite du conteneur
        void DeleteSprite(CSprite *pSprite);
 
    private:
	void RenderToScreen(sf::RenderWindow *pWindow);
 
        CSpriteManager();
        virtual ~CSpriteManager();
 
        typedef std::vector<CSprite*> m_Vector;
        m_Vector m_vSprite;    //Vecteur des sprites
        m_Vector::iterator m_vSpriteIter;    //Itérateur de parcours du vecteur
    };
}
 
#endif

Du coup dans le Renderer :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
void CRenderer::RegisterManagerToRendering(IManagerRender *pManager)
{
	if(pManager)
		m_vManager.push_back(pManager);
}
 
void CRenderer::Render(sf::RenderWindow *pWindow)
{
	for(m_vManagerIter = m_vManager.begin(); m_vManagerIter != m_vManager.end(); ++m_vManagerIter)
	{
		(*m_vManagerIter)->RenderToScreen(pWindow);
	}
}

Je peux accéder à la méthode RenderToScreen du SpriteManager grâce à la classe IManagerRender mais dans le main l'utilisateur lui ne peut y accéder

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
 
#include <iostream>
#include "SLE.h"
 
using namespace SLE;
using namespace Audio;
 
int main(int argc, char **argv)
{
	CSLEngine *pSLE = CSLEngine::GetInstance();
	pSLE->InitEngine(768, 576);
 
	CRenderer *pRenderer = CRenderer::GetInstance();
 
	CSpriteManager *pSpriteManager = CSpriteManager::GetInstance();
        pRenderer->RegisterManagerToRendering(pSpriteManager);
 
	CSprite *pRabbit = new CSprite("Data/Image/rabbit.png", 0.0f, 0.0f, 0);
	pSpriteManager->RegisterSprite(pRabbit);
 
	while(pSLE->IsRunning())
	{
	        pSLE->ActivateVerticaleSync(true);
		pSLE->BeginScene();
		pSLE->OnEvent();
		pRenderer->Render(pSLE->GetVideoMode());
		pSLE->EndScene();
	}
	pSLE->StopEngine();
 
	return EXIT_SUCCESS;
}

Et tout marche comme sous des roulettes ^^

Par contre je voudrais savoir si ce que j'ai fait respecte les principes de l'objet, et si non, y'a t'il une autre technique ?