"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.

[Paul Groke]

Alf P. Steinbach wrote:

* 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.

Well, I was just confused about the talk about a runtime solution. If
both types are known at compile time, and both types are complete,
then you can use Boost.Type_Trai ts.

http://www.boost.org/libs/type_traits/index.html

Look for "is_base_and_de rived". The only problem is, it will detect
if there exists a "base-berived" relationship between the two classes,
and it will report "true" even if the base type is not accessible
(protected/private inheritance) or if the cast is ambiguous (multiple
"base" are reachable from "derived"). In both cases a cast would fail
to compile - or in case of a dynamic cast maybe compile but fail at
runtime.

But there is also a "is_convertible <T,U>" template that will detect if
a "T" is convertible to an "U". To check if an implicit pointer
conversion is possible just feed in the pointer types, i.e.
"boost::is_conv ertible<A*,B*>: :value" will tell in your case.

The boost implementation of "is_convertible " is actually based on
Alexandrescu's design. And it should work right out of the box with
the majority of compilers.

[Alf P. Steinbach]

* Paul Groke:

Alf P. Steinbach wrote:

* 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.

Well, I was just confused about the talk about a runtime solution.

Uhm. If the types are known at all at run-time, then it can be done at
run-time, e.g. a dynamic_cast. If the types are unknown at run-time, i.e.
non-polymorphic objects used polymorphically , then the design is incorrect.

[snipped good references to Boost; the OP might also consider Loki]

--
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?

[Paul Groke]

Alf P. Steinbach wrote:

* Paul Groke:

Alf P. Steinbach wrote:

* Ralph D. Ungermann:
* tt******@gmx.de:
>Now I want to know [presumably at compile time], if A is a
>derivati on 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.

Well, I was just confused about the talk about a runtime solution.

Uhm. If the types are known at all at run-time, then it can be done at
run-time, e.g. a dynamic_cast. If the types are unknown at run-time, i.e.
non-polymorphic objects used polymorphically , then the design is incorrect.

[snipped good references to Boost; the OP might also consider Loki]

Since the "is_convertible " is a problem that can be dealt with at
compile-time I was assuming that maybe the problem was something
different. I have to say I didn't fully understand what exactly the
OP wanted to do until his last posting.

[tthunder]

I want to check, if one type is a derivation of another type!
I cannot use dynamic_cast, because I cannot create an instance of one
of these types (abstract).
Why want I do this at run-time? I have to detect errors which I made
when programming...

[Alf P. Steinbach]

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

I want to check, if one type is a derivation of another type!
I cannot use dynamic_cast, because I cannot create an instance of one
of these types (abstract).
Why want I do this at run-time? I have to detect errors which I made
when programming...

AFAICS solutions have been presented for all possible scenarios.

Perhaps if you could post a minimal real example.

Your earlier code snippets were not valid C++, and the explanations
didn't make sense.

--
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?

[tthunder]

Please check this code:
(Now it is a very good example)

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

class c1
{
virtual void foo() = 0;
....
};

class c2 : public c1
{
....
};

class c3 : public c2
{
....
};

class bad1
{
.....
};

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

class Base
{
public:
virtual ~Base() {}
};

template <class T>
class Checker : public Base
{
public:
T* ptr;

bool check(Base &base)
{
---- PSEUDO (with dynamic_cast, which does not work, if
ptr is NULL - a temporary instance cannot be created, because T can
always be a abstract class):
if (Checker *checker = dynamic_cast<Ch ecker *>(&base))
{
if (dynamic_cast<T *> (checker->ptr))
return true;
}
return false;
----
}
};
main()
{
Checker<c1> checker1;
Checker<c2> checker2;
Checker<c3> checker3;
Checker<bad1> checker4;

checker1.check( checker1) // return true
checker1.check( checker2) // return true
checker1.check( checker3) // return true
checker1.check( checker4) // return false, because bad1 cannot be
casted to c1

}
--------------

Do *****NOT***** use dynamic_cast!!! !!!
Do *****NOT***** use dynamic_cast!!! !!!
Do *****NOT***** use dynamic_cast!!! !!!

Please read the following line in my code:
---- PSEUDO (with dynamic_cast, which does not work, if ptr is NULL - a
temporary instance cannot be created, because T can always be a
abstract class)

[Alf P. Steinbach]

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

template <class T>
class Checker : public Base
{
public:
T* ptr;

bool check(Base &base)
{
---- PSEUDO (with dynamic_cast, which does not work, if
ptr is NULL - a temporary instance cannot be created, because T can
always be a abstract class):
if (Checker *checker = dynamic_cast<Ch ecker *>(&base))
{
if (dynamic_cast<T *> (checker->ptr))
This inner 'if' is equivalent to

if( checker->ptr != 0 )

because it casts a T* pointer to the very same type T*.

return true;
}
return false;
----
}
};

--
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?

[tthunder]

Of course you are right....
another example

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

class c
{
};

class c1 : public c
{
virtual void foo() = 0;
....
};
class c2 : public c1
{
....
};
class c3 : public c2
{
....
};
class bad1 : public c
{
.....
};
--------------------

class Base
{
public:
c *ptr;

virtual ~Base() {}
};
template <class T>
class Checker : public Base
{
public:
bool check(Base &base)
{
---- PSEUDO (with dynamic_cast, which does not work, if
ptr is NULL - a temporary instance cannot be created, because T can
always be a abstract class):
if (dynamic_cast<T *> (base.ptr))
return true;
return false;
----
}
void setPtr(c *p_ptr)
{
ptr = dynamic_cast<T *> (p_ptr);
}
};

main()
{
Checker<c1> checker1;
Checker<c2> checker2;
Checker<c3> checker3;
Checker<bad1> checker4;

checker1.check( checker1) // return true
checker1.check( checker2) // return true
checker1.check( checker3) // return true
checker1.check( checker4) // return false, because bad1 cannot be
casted to c1
}
--------------

Do *****NOT***** use dynamic_cast!!! !!!
Do *****NOT***** use dynamic_cast!!! !!!
Do *****NOT***** use dynamic_cast!!! !!!
Please read the following line in my code:
---- PSEUDO (with dynamic_cast, which does not work, if ptr is NULL - a

temporary instance cannot be created, because T can always be a
abstract class)

[Alf P. Steinbach]

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

Of course you are right....
another example

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

class c
{
};

class c1 : public c
{
virtual void foo() = 0;
...
};
class c2 : public c1
{
...
};
class c3 : public c2
{
...
};
class bad1 : public c
{
....
};
--------------------

class Base
{
public:
c *ptr;

virtual ~Base() {}
};
template <class T>
class Checker : public Base
{
public:
bool check(Base &base)
{
---- PSEUDO (with dynamic_cast, which does not work, if
ptr is NULL - a temporary instance cannot be created, because T can
always be a abstract class):
if (dynamic_cast<T *> (base.ptr))
return true;
return false;
This shouldn't compile because class 'c' isn't polymorphic.

Tested: it doesn't compile (when typos corrected in the rest of
code) using MSVC 7.1.

If the problem is to _only_ add some code in here that does "the right
thing", then that's impossible because 'c' isn't polymorphic. However,
you can add code elsewhere that retains type information. The easiest
would be to make class 'c' polymorphic by adding a virtual destructor,
and then write, here,

return (dynamic_cast<T *>( base.ptr ) != 0);

I don't understand your comment about the pointer being 0.

If the pointer is zero then it isn't pointing to anything: which result,
if any, would you like in that case?

}
void setPtr(c *p_ptr)
{
ptr = dynamic_cast<T *> (p_ptr);
}
};

main()
{
Checker<c1> checker1;
Checker<c2> checker2;
Checker<c3> checker3;
Checker<bad1> checker4;

checker1.check( checker1) // return true
checker1.check( checker2) // return true
checker1.check( checker3) // return true
checker1.check( checker4) // return false, because bad1 cannot be
casted to c1
}

--
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?

[tthunder]

You are right... the pointer does not point to anything! I know that
dynamic_cast does not work here! I know, that it return NULL, which is
the only right value! I know that there is another intention..

The result I need is different and simple: I do not need a pointer!!!!
I need BOOL! Is castable or is not castable! Of course I know, that a
NULL pointer is never castable. But my question: would it be castable
if there will be a value in it!

By the way: My Compiler (BCB 5.0) compiles the code... I only had to
correct syntax errors and implement "virtual ~c() {}" in class c.
Without dynamic_cast would not work!
But I say it again: dynamic_cast is NOT what I need.