Hi to all, While developing Shmem I wrote a smart pointer to represent relative pointers and now I'm experimenting with a multi-segment shared memory pointer to create growing multi-segment shared memory containers and allocators. Both pointers are based on boost smart pointer's interface (shared_ptr, etc...). In Shmem and possibly other generic libraries the developer wants pointer-independent code, so that the pointer type is a template parameter and the same code is used for relative, reference counted, intrusive, raw, or multisegment pointers. One of such uses, in Shmem, is for example, a memory allocator (a first fit, best fit algorithm) or an intrusive container. While developing pointer-independent code, however, I've seen that some features are present in boost (for example, get_pointer() function) and other features are missing, and I would like to propose them: 1. Overloads of static_pointer_cast, dynamic_pointer_cast, const_pointer_cast overloads for raw pointers, so that we can use pointer_xxx_cast in a generic way. 2. Add reinterpret_pointer_cast to complete cast family. 3. A protocol to obtain a pointer of the same type from any pointer. For example, if you want to generically use a pointer (for example, raw or relative pointer) in a class and you want to declare another pointer to other type (raw or relative, depending on the source): //typedef typename boost::pointer_to_other //<GenericPointer, NewType>::type MyNewPointer; //A new pointer to float values typedef typename boost::pointer_to_other <SmartPtr, float>::type MyFloatPointer; We should define how this protocol is implemented in boost smart pointers (for example, using overloading or a STL-like rebind mechanism) so that every boost smart pointer developer knows how to make its pointer type protocol-aware. Shmem uses rebind-like mechanism now, but the mechanism is not important. This way, a class can receive a void pointer like a template parameter and can be pointer-independent: template <class VoidPtr> class memory_manager { struct memory_block { //... }; typedef typename boost::pointer_to_other <VoidPtr, memory_block>::type BlockPtr; BlockPtr mp_free_list; }; I think these utilities are simple to develop and quite useful. What do smart pointer experts think? Regards, Ion