pointer and smart pointer address

Hello..

I want to get address of smart pointer but I have no idea how to do that - I need a unique key for each class instance..
I use boost smart pointer.

The way I would do it with normal pointer:

Code:

class someclass {
public:
	someclass() { }
	char test;
	bool yes;
};


typedef boost::shared_ptr<someclass> someclass_p;	//smart pointer

void main() {
	someclass *test = new someclass();
	DWORD bu = (DWORD) test;
	std::cout << "pointer: " << bu << "\n" ;
	
	someclass_p testp = someclass_p( new someclass() );
	//How do I get address here?
}

How to achieve this? Is this a 'good' way to do it?
Thanks a lot for help

according to http://www.boost.org/libs/smart_ptr/shared_ptr.htm
testp.get()

According to the FAQ: http://faq.cprogramming.com/cgi-bin/...&id=1043284376
Don't use void main(). Use int main().

Thanks guys..

One more question.. How can I get smart pointer when I have its address?
Example:

Code:

class someclass {
public:
	someclass() { }
	char test;
	bool yes;
};

typedef boost::shared_ptr<someclass> someclass_p;	//smart pointer

int main() {
	someclass *test = new someclass();
	DWORD bu = (DWORD) test;
	std::cout << "pointer: " << bu << "\n" ;
	
	someclass_p testp = someclass_p( new someclass() );
	ULONG_PTR uptr = (ULONG_PTR)testp.get();
	//so I have pointer address here
	//How do I get testp from uptr?
	
	return 0;
}

You can't. The return value of get() is the internally stored raw pointer location. It has no information about any smart pointers that manage it.

Just to clarify, if there is more than one shared_ptr sharing a someclass instance, do you want each shared_ptr to return a different address, or should it be the same for all shared_ptr's containing the single someclass instance?

Depending on why you need the address, there are other options. For example, if you are just trying to store shared_ptr objects in a map, you can create a comparison function that compares shared_ptr<someclass> objects by comparing the return value of get(). You would still store the shared_ptr, so you would always have it available, but the unique key would be based on the internal pointer.

Originally Posted by Daved

Depending on why you need the address, there are other options. For example, if you are just trying to store shared_ptr objects in a map, you can create a comparison function that compares shared_ptr<someclass> objects by comparing the return value of get(). You would still store the shared_ptr, so you would always have it available, but the unique key would be based on the internal pointer.

This is actually what I thought of.. And seems the best way to solve my problem..

Why I want to do this?
I pass pointer address (of someclass) to windows api, which will return the address when something happens with this class (instance).
Then I call functions to process data inside that class.

It is more complicated if I use smart pointers instead of normal pointers.

Would it be okay to call functions with raw pointer instead of shared/smart pointer?
Wouldnt that lose the benefit of smart pointers?

If I decide for option you mentioned, would map slow down preformance of my program? There will be like 10 000+ instances of someclass.

On a side note, you are assigning new *test but not calling delete or setting the pointer to NULL when the peogram terminates. Becareful of this, dont create dangling pointers.
I may have this wrong assumsion, as that could just be example code, but I am going on what I see...

You need something to own the pointers. A container of shared_ptr's is great for that. If you pass the raw pointer to the windows API it will be fine to call member functions from the raw pointer instead of the shared_ptr. That will not lose any smart pointer benefits because the smart pointer is meant only to help manage the memory/construction/destruction of the object.

How are you storing the shared_ptrs now? Are they all in a container already? Are they members of other classes?

One option is to have an std::set<shared_ptr<someclass>, CompareByRawPointer> where CompareByRawPointer is a comparison function for shared_ptr<someclass> objects that uses the raw pointer. This should not slow down your performance too much, as lookup is fast in a set. You could also use a unordered_set if you were really concerned about it, since a unordered_set is potentially much faster than a set. Finally, if you create all your shared_ptrs first, you could use a vector, then sort it after all objects have been inserted: std::sort(vec.begin(), vec.end(), CompareByRawPointer). With all these options you can find the shared_ptr from the raw pointer if you really need to without much of a performance hit, bt you shouldn't need to do that excpet for when you want to delete the object.

Originally Posted by Daved

How are you storing the shared_ptrs now? Are they all in a container already? Are they members of other classes?

Right now I store shared_ptrs in a vector which is a member of another class.

You can call member functions from the raw pointer without any issues. Is there any reason you want to get the shared_ptr from the raw pointer? The only one I can think of would be to remove an item from that vector when all you have is the raw pointer. If you never have to do that, then I don't think you should worry about it.

Originally Posted by Daved

You can call member functions from the raw pointer without any issues. Is there any reason you want to get the shared_ptr from the raw pointer? The only one I can think of would be to remove an item from that vector when all you have is the raw pointer. If you never have to do that, then I don't think you should worry about it.

I think I will have to locate smart pointer anyway, so I will be able to remove it from container. One function would remove the item from the cointainer (vector) and the others just process the data inside the item (class).

So actually even if I call functions with raw pointer I wont have benefit, because I will have to locate the smart pointer anyway to remove the item from container when its needed?
So I just have to focus on most efficient container and optimize it..

Please correct me if I'm wrong.

Thanks for help again

>> So actually even if I call functions with raw pointer I wont have benefit, because I will have to locate the smart pointer anyway to remove the item from container when its needed?

Still, the lookup of the smart pointer will take some processing that is not necessary. It sounds like you still need to provide the ability to look up the smart pointer, but you should only actually do it if you need to remove the object. Otherwise, use the raw pointer directly.

Looking up the smart pointer to call the member functions has no benefits and so you should just not do it.

Hey Daved, thanks for your help.. You're very helpful..

One more thing.. How could I find the right smart pointer if I decide to go for std::set? Map would work just perfectly but I am worried about the preformance.

Thanks again

Map would work fine, but it is an unnecessary duplication of data (the raw pointer would be stored twice). If that seems a lot more intuitive for you, use the map. The performance hits are unlikely to be noticable, even with 10,000+ objects.

For a set to work you would need to provide your own compare function like I mentioned above. A simple version would be a function returning bool and taking two shared_ptr<someclass> references to const. That function would just return true if the first parameter's get() was less than the second, otherwise false. This would sort the shared_ptr's in the set based on the raw pointer value, so you wouldn't need the map. You'd still have to figure out how to use a raw pointer to lookup the value in the set. Normally you'd construct a temporary shared_ptr with the raw pointer, but I'm not sure if that would accidentally delete the object. You'd have to do some research into how shared_ptr works to make sure if you really want to go this route. Otherwise stick with the map.

Thank you.. Map seems the best and easier option.