class A {};
class B {};
template <typename AB>
class X : public AB {
void DoSomethingDependingOnAorB{};
};
//somewhere else:
class Z : public A, public B {
};
who was a class inherited from? (C++)
Author
Hi, Im trying to figure out what a certain class was inherited from.
The problem is that one class inherits another and I want it to execute specific code depending on the class it was inherited from. I cant give all classes the same function which is implemented differently because I use multiple inheritance with these classes somewhere else.
I gotta admit I''m having a hard time figuring out what you''re trying to do. It would probably help if you could post more code so the errors had some context. I''m not a particularly big fan of multiple inheritance as it is, but I''d give your problem a shot if I could understand it better.
First off my initial response is that any design that would need such a capability could use some fundamental changes.
But, good design aside:
To use such c++ capabilities most compliers require you to manualy turn on ''run time type identification'' or rtti.
But, in 90% of cases, if your using rtti there is a better, simpler way to do it instead.
But, good design aside:
template<typename T>void DoDifferent(T var){ A* tryA = dynamic_cast<A*>(&var); if(tryA != 0) //its of type A B* tryB = dynamic_cast<B*>(&var); if(tryB != 0) //its of type B}To use such c++ capabilities most compliers require you to manualy turn on ''run time type identification'' or rtti.
But, in 90% of cases, if your using rtti there is a better, simpler way to do it instead.
Sounds like you just need to make the function virtual in the base classes. The implementation from whichever class you derive from will be the one that runs.
[edited by - merlin9x9 on October 22, 2003 2:02:18 AM]
[edited by - merlin9x9 on October 22, 2003 2:02:18 AM]
You dont need to do any runtime stuff for this, the information concerning who you are inheriting from are available at compiletime!
I would go with the suggestion given by the AP, use template specialization.
I would go with the suggestion given by the AP, use template specialization.
class A {};class B {};template<typename AorB>class X : public AorB{};template<>class X<A> : public A{// specialize for A};template<>class X<B> : public B{// specialize for B};class Z : public A, public B{// shizzle, inherit from both};#include <iostream>class A {};class B {};template <class T>class C : public T{ template <class U> struct DoSomething_ { // ASSERT maybe? void operator () (void) {} }; template <> struct DoSomething_<::A> { void operator () (void) { std::cout << "Do something A" << std::endl; } }; template <> struct DoSomething_<::B> { void operator () (void) { std::cout << "Do something B" << std::endl; } };public: C () {} DoSomething_<T> DoSomething; };int main(){ C<A> test1; C<B> test2; test1.DoSomething(); test2.DoSomething(); return 0;}DoSomething inst a member function but rather an instance of a functor. Kinda interesting when you think about it
daerid method is also good.
[edited by - Amnesty on October 22, 2003 3:11:40 AM]
Author
Thanks guys, partial template specialization sounds like exactly what I want. (and thanks to dareid for spelling it out
)
First off my initial response is that any design that would need such a capability could use some fundamental changes.
These were my thoughts also, but im not sure how to redesign it.
I basically want to use this to build up customized base classes, ie: reference counted? simplememorymanaged? heapdetection? memorypooled? statuslogging? factoryobject? etc..
the specific problem i was trying to solve was that if heapdetection was used, then the simple memory manager should not automatically delete the object when garbagecollection is called, but otherwise i guess just asume everything was in the freestore and delete it. likewise for things with reference counting..
is there a better design?
)First off my initial response is that any design that would need such a capability could use some fundamental changes.
These were my thoughts also, but im not sure how to redesign it.
I basically want to use this to build up customized base classes, ie: reference counted? simplememorymanaged? heapdetection? memorypooled? statuslogging? factoryobject? etc..
the specific problem i was trying to solve was that if heapdetection was used, then the simple memory manager should not automatically delete the object when garbagecollection is called, but otherwise i guess just asume everything was in the freestore and delete it. likewise for things with reference counting..
is there a better design?
Author
Hi guys, just another question now on template specialization,
this code snippet illustrates the problem:
Basically, how do I specialize a template for a base class, when the template inherits from another templated class (and that class contains the base class).
Thanks!
this code snippet illustrates the problem:
class A {};template <typename T> class A {};class B {};template<typename AorB>class X : public AorB{};template<> class X<A> : public A{// specialize for A};//but NOW what:template<typename XorY>class Z : public XorY{};//the following code is wrong:template<> class X<A> : public A{//specialize for A//!but I also want this to specialize for X<A>};Basically, how do I specialize a template for a base class, when the template inherits from another templated class (and that class contains the base class).
Thanks!
This topic is closed to new replies.
Advertisement
Popular Topics
Advertisement
