"dynamic_ca st" with instance of an abstract class ?!?

[tthunder]

Hi @all,

I've got an interesting problem.

These are my classes:

----------------------

class fooBase
{
virtual func();
}

class fooA : public fooBase
{
virtual func();
};

class fooB : public fooBase
{
virtual func1() = 0;
virtual func2();
};

class fooB2 : public fooB
{
virtual func1();
}

----------------------

// Template class
class myFooBase
{
fooBase *m_pPtr;
};

template <class T>
class myFoo : public myFooBase
{
public:

myFoo(fooBase *p_pPtr) :
m_pPtr(p_pPtr)
{
}

bool isCompatible(my Foo *p_p)
{
// Check, if p_p is compatible (dynamic_castab le) to T

// Possible way:
T *TempPtr = new T();
if (dynamic_cast<T *> (p_p->m_pPtr))
}
};

----------------------

int main()
{
fooB2 *TEST1 = new fooB2();

myFoo<fooB2> test1(dynamic_c ast<fooBase *>(new fooB2()));
myFoo<fooBase> test2(dynamic_c ast<fooBase *>(new fooBase()));

// Test: OK
test2.isCompati ble(&test1);

// Cannot create, because of new T() => fooB is an abstract class
myFoo<fooB> test3(dynamic_c ast<fooBase *>(new fooB3()))
}

----------------------

As you see, I need another way to check, if to base classes are
dynamically castable or have the same base classes.

[poclea]

Use RTTI (typeid operator).

[Paul Groke]

// Template class
class myFooBase
{
fooBase *m_pPtr;
};

template <class T>
class myFoo : public myFooBase
{
public:

myFoo(fooBase *p_pPtr) :
m_pPtr(p_pPtr)
{
}

bool isCompatible(my Foo *p_p)
{
// Check, if p_p is compatible (dynamic_castab le) to T

// Possible way:
T *TempPtr = new T();
if (dynamic_cast<T *> (p_p->m_pPtr))
}
};

Why do you want to leak memory? Why "new T()"? The
"if dynamic_cast<>( )" alone will do just fine. BTW: if you
just write "myFoo *p_p" in the parameter list it actually
means "myFoo<T> *p_p" - i.e. if you only assign Ts (or derived)
to "m_pPtr" it will always be compatible!
I think what you're trying to do would read something like:

// inside template <class T> class myFoo ...:
template<class U>
bool isCompatible( myFoo<U> const & other )
{
return !! dynamic_cast<T* >(other.m_pPtr) ;
}

[tthunder]

How to use typeid to check if a class A is the same or a derivation of
class B?

I have explained my problem wrong... I'm sorry for my bad English!

I have a better example:

template <class A, class B>
bool testDerivation( )
{
// check, if A is the same or a derivation of class B

// typeid(A) == typeid(B) would be possible.... but only for
Equality... what about derivation?
}

How, to implement such a function?
As I said, I cannot use dynamic_cast, because B (or A) can be abstract.
Because of this I cannot create an instance.

[Jan Meskens]

You can also put dynamic_cast within an if/else structure.

eg for testing if a baseClassInstan ce is 'castable' to a CDerivedClass
type :
if(CDerivedClas s* der == dynamic_cast<CD erivedClass*>(b aseClassInstanc e)){
der->doSomething( );
}
else if(/*testing to other type*/){
}

//and so on...
Jan

[tthunder]

My code is terribly wrong!!!! When I was constructing my code, I was
sleeping...
Normally I can use dynamic_cast<> perfectly...

I have a template class with a pointer

template <class T>
T *myVar;

Now I want to know (in runtime), if this T is for example an base class
of XYZ...

template <class XYZ>
XYZ *myVar2;

BUT... I cannot use dynamic_cast for this... Because dynamic_cast needs
myVar! I want to use T...

Ohhhhh, my English... sorry for that... nobody knows what I want to do?

[Paul Groke]

tt******@gmx.de wrote:

My code is terribly wrong!!!! When I was constructing my code, I was
sleeping...
Normally I can use dynamic_cast<> perfectly...

I have a template class with a pointer

template <class T>
T *myVar;

Now I want to know (in runtime), if this T is for example an base class
of XYZ...

template <class XYZ>
XYZ *myVar2;

BUT... I cannot use dynamic_cast for this... Because dynamic_cast needs
myVar! I want to use T...

Ohhhhh, my English... sorry for that... nobody knows what I want to do?

T and XYZ are both static types, so where's the runtime thing?
This is really starting to confuse me. Why don't you just tell us what
you are trying to do, and why (=what do you need this functionality for)
and maybe we can find a solution.

[tthunder]

Ok... what follows now is not exactly what I want to do. But if anyone
can solve this problem, I can solve my own problem!

I have two class types: class A and B. The exact type of those are
defined in a template: e.g. template <class A>, template<class B>

Now I want to know, if A is a derivation of B!
Of course I could use dynamic_cast<>. ....
Normally I could use dynamic_cast and one instances: A* classA = new
A(); dynamic_cast<B *>(classA) etc.
BUT I cannot of an instance for an abstract class... "Aabstract* classA
= new Aabstract()" fails...

[Ralph D. Ungermann]

tt******@gmx.de wrote:

Ok... what follows now is not exactly what I want to do. But if anyone
can solve this problem, I can solve my own problem! I have two class types: class A and B. The exact type of those are
defined in a template: e.g. template <class A>, template<class B>

Now I want to know, if A is a derivation of B!

Since std::type_info offers no way to check the hierarchy, and nobody
else provided a good answer yet, I suppose, that this can't be done in
general.
But I cannot imagine, what the following is good for:

template <class A, class B>
void f()
{
if ( typeid(A).has_b ase(typeid(B)) ) // fictitious!
{
// you can't create an A or B (might be abstract)
// you can't convert an A (B might be a private base)
}
else
{
// A might otherwise be perfectly convertible to B anyway
}
}

Can you name a single C++ statement, that is guaranteed to work in one
case, but might fail in the other case? I don't see one.
Why don't you just post your *real* problem?
Ralph

[Alf P. Steinbach]

* Ralph D. Ungermann:

* tt******@gmx.de:

Now I want to know [presumably at compile time], if A is a
derivation of B!

Since std::type_info offers no way to check the hierarchy, and nobody
else provided a good answer yet, I suppose, that this can't be done in
general.

Andrei Alexandrescu presented one solution to this problem in his "Modern
C++ Design". It's based on having a function with one overload that
accepts a B, and one that accepts anything else. Then you pseudo-call it
(within a sizeof-expression) with an A, and check which one is selected.

--
A: Because it messes up the order in which people normally read text.
Q: Why is it such a bad thing?
A: Top-posting.
Q: What is the most annoying thing on usenet and in e-mail?