"Christopher" <cp***@austin.rr.comwrote in message
news:d0**********************************@m36g2000 hse.googlegroups.com...
>I am surprised this hasn't come up for me more in the past, but the
situation is:
I need to have an interface that is usable for all
I need to have an interface that is only usable for some
I do not really know of a good way to achieve this. If I use friend
functions, I can no longer make methods virtual, right?
Example:
I am making a texture class for my graphics library
The only thing the application should have access to is a string
filename to create it with, perhaps dimensions, and a few other
things.
However, some classes inside the engine, such as say the renderer
should have access to the hardware level texture resource, which is in
this case a pointer to a struct from a 3rd party library. So, I need
accessors for my renderer to use, but do not want them to be available
to the application. Both are using the same class.
How about something like this below. I've created a class hierarchy based
upon an abstract interface for a "renderer" and
and "advanced" renderer subclass, and two rendering engines, an ordinary and
an advanced.
You create the "advanced" renderer and pass it to the two engines, the
ordinary engine is
expecting an ordinary renderer and so only uses methods of the ordinary
render, and the advanced
engine expects the Full Monty.
#include <iostream>
class IRenderer{
public:
virtual void render () = 0;
};
class IAdvancedRenderer : public IRenderer
{
public:
virtual void render () = 0;
virtual void renderAdvanced() = 0;
};
class RendererImpl : public IAdvancedRenderer
{
public:
RendererImpl(){}
virtual void render(){ std::cout << "Render" << std::endl;}
virtual void renderAdvanced(){ std::cout << "Advanced Render" <<
std::endl;}
};
class RenderingEngine
{
public:
RenderingEngine( IRenderer& renderer)
:_renderer(renderer)
{}
void render()
{
_renderer.render();
}
private:
IRenderer& _renderer;
};
class AdvancedRenderingEngine
{
public:
AdvancedRenderingEngine( IAdvancedRenderer& renderer)
:_renderer(renderer)
{}
void renderAdvanced()
{
_renderer.renderAdvanced();
}
void render()
{
_renderer.render();
}
private:
IAdvancedRenderer& _renderer;
};
IAdvancedRenderer* createRenderer()
{
return new RendererImpl();
}
int main(int argc, char *argv[])
{
RendererImpl renderer ;
AdvancedRenderingEngine advancedEngine( renderer);
RenderingEngine ordinaryEngine( renderer);
ordinaryEngine.render();
advancedEngine.renderAdvanced();
return 0;
}
