Re: Polymorphism and "interface_cast"
....
You have presented the wrong approach to the problem. This should never
be done this way.
....
I believe that this issue should be generalized into
"how to simplify writing delegating functions and classes".
for example:
class InterfaceAdapter : public Interface {
public:
using Interface::auto (cat->auto);
private:
Cat * cat;
};
Now you could make all variants of interface_cast
in the library... and I would have a way to write
adapters more quickly.
I agree that the InterfaceAdapter created manually was impractical.
Following original motivations:
1) The object doesn?t need to know how others see it
2) The polymorphism and interfaces could be added later
Here is different approach:
Let's say I have a button class:
struct Button {
void Draw(Args args) {...}
void KeyDown(int key) {...}
void MouseDown(int x, int y) {...}
};
I could use this class directly like:
struct Window
{
Button button;
void OnPaint() { ... button.Draw(args); ... }
...
}
Now, let's say I want to see a Button as a polymorphic Control and
have a list of different controls implementing this interface.
I could make Control derived from "KeyEventReceiver",
"MouseEventReceiver" and "IDraw" or just put all functions inside
Control without any extra hierarchy. But I don't want to decide
anything before to see the algorithms and use.
An alternative to the interface_cast could be:
struct NonPolymorphic {};
Template<class TInterface = NonPolymorphic>
struct Button : public TInterface {
void Draw(Args args) {...}
void KeyDown(int key) {...}
void MouseDown(int x, int y) {...}
};
Now, we have the Button class and some interface.
*The Button doesn't need to know anything about the TInterface. (1)
To use a non-polymorphic Button we could do:
Button<> button;
To see a Button as a polymorphic Control we could do:
* First declare the interface. (How we want to see the Button) (2)
struct Control
{
virtual void Draw(Args args) =0;
virtual void KeyDown(int key) =0;
virtual void MouseDown(int x, int y) =0;
}
And pass the interface type to the template argument
vector<Control*> v;
v.push_back( new Button<Control> );
Basically the pattern is to leave the Base class (interface) empty.
The interface is decided according with the use.
If the Button has the same view in the project a typedef is better
than see templates everywhere.
-
http://www.thradams.com/
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]