Classe abstraite

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

L'amitié semble convenir ici.

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?

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

Code:

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:

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:

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:

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 ?