pointer_to_other.hpp

# Header boost/pointer_to_other.hpp

The pointer to other utility provides a way, given a source pointer type, to obtain a pointer of the same type to another pointee type. The utility is defined in boost/pointer_to_other.hpp.

There is test/example code in pointer_to_other_test.cpp.

## Contents

- Rationale
- Synopsis
- Example

## Rationale

When building pointer independent classes, like memory managers, allocators, or containers, there is often a need to define pointers generically, so that if a template parameter represents a pointer (for example, a raw or smart pointer to an int), we can define another pointer of the same type to another pointee (a raw or smart pointer to a float.)

    template <class IntPtr>
    class FloatPointerHolder
    {
       // Let's define a pointer to a float
       typedef typename boost::pointer_to_other
          <IntPtr, float>::type float_ptr_t;
       float_ptr_t float_ptr;
    };

## Synopsis

    namespace boost {

    template<class T, class U>
       struct pointer_to_other;

    template<class T, class U, template <class> class Sp>
       struct pointer_to_other< Sp<T>, U >
    {
       typedef Sp<U> type;
    };

    template<class T, class T2, class U,
            template <class, class> class Sp>
       struct pointer_to_other< Sp<T, T2>, U >
    {
       typedef Sp<U, T2> type;
    };

    template<class T, class T2, class T3, class U,
            template <class, class, class> class Sp>
    struct pointer_to_other< Sp<T, T2, T3>, U >
    {
       typedef Sp<U, T2, T3> type;
    };

    template<class T, class U>
    struct pointer_to_other< T*, U >
    {
       typedef U* type;
    };

    } // namespace boost

If these definitions are not correct for a specific smart pointer, we can define a specialization of pointer_to_other.

## Example

    // Let's define a memory allocator that can
    // work with raw and smart pointers

    #include <boost/pointer_to_other.hpp>

    template <class VoidPtr>
    class memory_allocator
    {
       // Predefine a memory_block
       struct block;

       // Define a pointer to a memory_block from a void pointer
       // If VoidPtr is void *, block_ptr_t is block*
       // If VoidPtr is smart_ptr<void>, block_ptr_t is smart_ptr<block>
       typedef typename boost::pointer_to_other
                <VoidPtr, block>::type block_ptr_t;

       struct block
       {
          std::size_t size;
          block_ptr_t next_block;
       };

       block_ptr_t free_blocks;
    };

As we can see, using pointer_to_other we can create pointer independent code.

Last revised: $Date: 2006-03-18 06:58:20 -0800 (Sat, 18 Mar 2006) $

Copyright 2005, 2006 Ion Gaztaņaga and Peter Dimov. Use, modification, and distribution are subject to the Boost Software License, Version 1.0.
(See accompanying file LICENSE_1_0.txt or a copy at < http://www.boost.org/LICENSE_1_0.txt>.)