Re: Convenient typedef of base classes
Hakusa@gmail.com wrote:
On Dec 2, 10:34 am, Dragan Milenkovic <dra...@plusplus.rs> wrote:
Was something like this ever suggested?
(I'm expecting the answer - it's already in C++0x :-)
template <typename A, typename B>
class Bar : public Foo<typename std::remove_const<A>::type, B> = Base {
...
};
to be equivalent to:
template <typename A, typename B>
class Bar : public Foo<typename std::remove_const<A>::type, B> {
typedef Foo<typename std::remove_const<A>::type, B> Base;
...
};
I think this might lead to disorderly code, especially in cases of
multiple inheritance where you'd have base1 and base2.
The programmer may choose to make a typedef or may choose not to.
"Base1" and "Base2" are very poor choices. How about "Base"
and "Interface", or whatever is the meaning of that inheritance.
Maybe "Helper_base", "Adaptee" or even "Wrapped_stuff".
template <typename A, typename B>
class Bar : public Foo<typename std::remove_const<A>::type, B> = Base
{
// Typedef list.
typedef type-expression Type1;
typedef type-expression Type2;
typedef type-expression Type3;
void f( Base x );
};
If I were reading this code, I would see Base and, not recognizing the
type and assuming it's a typedef, I'd look at the typedef list. Not
seeing it, I would be lost. Furthermore, I would not be in the habit
of looking at the inheritance line for typedef info and it may not be
intuitive when first I see it. It also further clutters the class
definition. However...
Maybe a real world example where you use a base class in function
declaration would help me understand why this bothers you. I usually
use it in implementation, not interface.
template <typename A, typename B>
class Bar : public typedef Bar::Base {
// Typedef list.
typedef type-expression Type1;
typedef type-expression Type2;
typedef type-expression Type3;
typedef Foo<typename std::remove_const<A>::type, B> Base;
void f( Base x );
};
would be more appealing to me. Here, Bar:: signifies that the typedef
is internal and it's intuitive because I already understand scope
resolution, so this introduced no new logic to me.
It could work for private/protected inheritance. But IMHO, when
working with an "is-a" relationship, it's very messy to understand
that Bar is-a Foo here. And this relationship is quite important,
wouldn't you agree? More important than making a convenient name
for it. Also, I guess this would also be very complicated to implement.
Or perhaps
template <typename A, typename B>
// Typedef list.
typedef type-expression Type1;
typedef type-expression Type2;
typedef type-expression Type3;
typedef Foo<typename std::remove_const<A>::type, B> Base;
class Bar : public Base {
void f( Base x );
};
Although, this is not preferable to me as there is a lot of
information about the class presented before I've even read its name!
And, this would be an odd and unconventional place to hide the typedef
list.
Heh... You don't prefer it, yet to me, this one looks better than
former ones.
Ok, if in
/class Bar : public Foo<typename std::remove_const<A>::type, B> = Base/
it's too hard to find the word "Base", and also because "=" should
assign rhs to lhs not vice-versa, maybe this would do:
class Bar : public Base = Foo<typename std::remove_const<A>::type, B>
but then again, I'd like to bring Foo in the first plan because
it is more important than the fact we made a typedef... so...
class Bar : public Foo<typename std::remove_const<A>::type, B> -> Base
Any thoughts?
--
Best regards,
Dragan
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]