Thank you, i didnt realize Note 2.
About Note 3, it isnt really a project. i only need a dirty hack.
Why hack when you can keep it simple?
An integer can't store the adress of an object. Thats true even if on
your particular platform: a pointer happens to occupy the same size as
a pointer. On mine its not (64 bit) - not that it matters. An integer
is not an address. A pointer is not just some value/number - it also
implies a type. Would be funny if a program was to delete/deallocate
an integer instead of the complex object (can you say memory leak?).
You could employ a RTTI where typeid( *p ).name() returns the type
stored at a given pointer p. That, however assumes you've got
polymorphism (at least one virtual function). Here is an example using
boost::shared_ptr:
#include <iostream>
#include <vector>
#include <typeinfo>
#include <algorithm>
#include "boost/shared_ptr.hpp"
class A { virtual void foo() { } };
class B : public A { };
class C : public A { };
template< typename T = A >
struct TypeName
{
void operator()(boost::shared_ptr< T >& bsp)
{
std::cout << typeid(*(bsp)).name() << std::endl;
}
};
int main()
{
typedef boost::shared_ptr< A > SharedPtrA;
std::vector< SharedPtrA > va;
va.push_back(SharedPtrA(new A));
va.push_back(SharedPtrA(new B));
va.push_back(SharedPtrA(new C));
std::for_each(va.begin(), va.end(), TypeName< >());
}
/* your output will vary
1A
1B
1C
*/
As already noted elsewhere, such a design is usually unneccessary and
often indicative of a design issue.
Hacking sucks.
The objects already know what their dynamic type is.
You might as well have each type do_the_foo() in whatever way they
do_the_foo (overide foo() where and if needed).
class A { virtual void foo() { } };
class B : public A { void foo() { } };
class C : public A { void foo() { } };
int main()
{
...
// i don't care which one of the above you might be, just
do_the_foo()
p_a->foo();
...
}
It doesn't get any simpler.
