Re: Can i get the class of an object of which i only have the
address?
On Jan 17, 8:48 am, bob the builder <brulsm...@hotmail.com> wrote:
On 17 jan, 14:33, Ondra Holub <ondra.ho...@post.cz> wrote:
On 17 Led, 12:44, bob the builder <brulsm...@hotmail.com> wrote:
Can i get the class of an object of which i only have the address?
Lets say i have 3 classes: AClass,BClass,CClass.
i also have an object of each class: aObject, bObject, cObject
And finally i have an integer: integerX.
Now i let let intergerX be the address of one of the objects (aObject,
bObject or cObject) but i dont know which.
Can get the class of the object at the address contained in integerX?
and how?
With some modification you can achieved what you need.
If all candidate classes have 1 common parent class, you can try to
dynamic_cast it to derived class type.
class Base { };
class AClass: public Base { };
class BClass: public Base { };
// ...
Base* ptr = ...; // Get the pointer from somewhere
AClass* aptr = dynamic_cast<AClass*>(ptr);
if (aptr != 0)
{
// ptr points to AClass or class derived from AClass
}
Note: If you have hierarchy of classes, you have to check child
classes and then their parents.
Note 2: Storing pointers in integer variables is bad idea. Many
programs are not portable to other platforms, because their author
supposed, that pointer has the same size as integer.
Note 3: In well designed project you will not need any stuff mentioned
above.
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.