template class inheritance syntax - c++

Question

My intention is to have some base class CBaseClass that, amongst other things, serves as a container to some members of type CBaseMember; then to derive a CDerivedClass : public CBaseClass that holds CDerivedMember : public CBaseMember.
I can't use a pointer to CBaseMember and initialize it with a CDerivedMember object in CDerivedClass because it's a multiple inheritance situation, CDerivedMember has an additional interface (a pure abstract base class) that is irrelevant to CBaseClass implementation but needs to be visible to CDerivedClass. Lots of dirty casting is something that I would very much like to avoid.
My solution to this problem was to make CBaseClass a template, like this:
//declaration
template <class Member>
CBaseClass
{
protected:
virtual void GenericMethod();
virtual void VirtualMethod() = 0;
Member* member;
};
//definition
template <class Member>
void CBaseClass<Member>::GenericMethod()
{
member->SomeMemberMethod();
}
and then to inherit CDerivedClass from it, like this:
//declaration
CDerivedClass : public CBaseClass<CDerivedMember>
{
protected:
virtual void VirtualMethod();
};
//definition
void CDerivedClass::VirtualMethod()
{
member->SomeDerivedMethod();
}
Predictably, this doesn't work (CBaseClass<CDerivedMember>::GenericMethod() is unresolved, for obivious reasons), but unfortunatly I don't know how to change my code to mean what I intend for it to mean.
Can anyone please explain how those things are done properly - or suggest another solution for my problem?
Thanks!

Answer 1

Well, you could keep the dirty typecasts at one place, encapsulated in your class. Therefore, it's not really dirty anymore.
class CBaseMember {
public:
virtual void SomeMemberMethod(){}
};
class CDerivedMember : public CBaseMember {
public:
virtual void SomeMemberMethod() { /* do other stuff */ }
virtual void SomeDerivedMethod() {}
};
//declaration
class CBaseClass
{
protected:
virtual void GenericMethod();
virtual void VirtualMethod() = 0;
CBaseMember* member;
virtual CBaseMember * getMember() {
return member;
}
};
//definition
void CBaseClass::GenericMethod()
{
getMember()->SomeMemberMethod();
}
//declaration
class CDerivedClass : public CBaseClass
{
protected:
virtual void VirtualMethod();
virtual CDerivedMember * getMember() {return static_cast<CDerivedMember *>(member);}
};
//definition
void CDerivedClass::VirtualMethod()
{
getMember()->SomeDerivedMethod();
}
In summary, you do the dirty typecasting inside the getMember() method of the derived class. At that point you should be sure that the type of the member is CDerivedMember anyway. So, as long as you know that the pointer you have is of type CDerivedClass you will have access to its CDerivedMember without typecasting. If you have to fall back to a CBaseClass pointer, you'll naturally fall back to the CBaseMember while accessing its member.

Answer 2

I suspect that you want to get rid of the templates, because the snippet you provided would work (if you added the class keyword to the declaration of your types).
If you want to avoid downcasts from CBaseMember* to CDerivedMember*, you can approach the situation with dynamic binding and covariance:
class CBaseClass {
private:
CBaseMember* const baseMember;
protected:
virtual CBaseMember* member() const {
// ^^^^^^^^^^^
return baseMember;
}
/* everything else you need here. Just never ever access `baseMember` directly */
};
class CDerivedClass : public CBaseClass {
private:
CDerivedMember* const derivedMember;
protected:
virtual CDerivedMember* member() const {
// ^^^^^^^^^^^^^^
return derivedMember;
}
/* everything else you need here. Just never ever access `derivedMember` directly */
};
However, this only works if you will never change the member to point somewhere else, because you cannot pull this trick with a setter: virtual void CBaseClass::member(CBaseMember*) cannot be overridden with virtual void CDerivedClass::member(CDerivedMember*).
Note that you will still be carrying the baseMember pointer in your CDerivedClass around, although it is never ever used. So if memory is important to you, this might not be viable.