Re: Design problem with inheritance
<sy8111.public@gmail.com> wrote:
whiteflags99@hotmail.com wrote:
here ABC is a fatty interface since intABC does not require char
version of get/set members
and charABC does not require int version of get/set members.
If I remove Get/Set members from ABC class and put int versions in
intABC and char versions in charABC then I have to use
downcasting to
call specific versions.
so is there a good design to remove fatty interface from the ABC
and at
the same time i should not use downcasting and another
constraint is I
should use ABC polymorphically?
I believe you have two possible paths to take: You can make the getters
and setters pure virtual methods, requiring the derived classes to
implement their own, or you can make ABC a template class.
These two ways are not so good. The first one doesn't solve design
drawback, of which derived class's implementation detail is exposed in
base class. The second one, template, whose pointer are treated as two
independent classes and thus can't be used in one container.
I think the only choice is to use downcasting when you get base class's
pointer from container and call setter/getter from casted derived class
pointer.
A discriminated union of the templated bsse classes seems like a
solution. using a reference wrapper or smart_ptr as the types in the
discriminated pseudo union preservws the the polymorphism from each
templated
base clas. Boost's variant is a possibliity for implementation.
then a 'visitor' is used to read the items out of the container.
and dispatch the virtual functions for each base type.
That implemnts every thing with pure virtual functions.
a virtual dtor and possibly the templated base classes are derived from
a common base class o common generic pure virtual functions.
Bainstorming at the moment during thw week l'll get to a more modern
computer and compiler to really test it. Should be doable.
struct common_base
{
virtual void operation1()=0;
virtual void operation2()=0;
virtual ~common_base(){}
protected:
common_base(){}
};
template <class Var>
class middle:public common)base
{
protected:
middle(){}
public:
virtual void set(const Var &)=0;
virtual Var get() =0;
};
class A:public middle<int>
{
...
}
class B:public middle<char>
{
...
};
class controller
{
typedef boost::variant
<
boost::reference_wrapper<middle<int> >,
boost::reference_wrapper<middle<char> >
> value_type;
std::vector<value_type> array;
...
}
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]