diff --git a/include/boost/smart_ptr/allocate_shared_array.hpp b/include/boost/smart_ptr/allocate_shared_array.hpp
index 5857c47..0bd9b04 100644
--- a/include/boost/smart_ptr/allocate_shared_array.hpp
+++ b/include/boost/smart_ptr/allocate_shared_array.hpp
@@ -106,24 +106,6 @@ struct sp_array_count<T[N]> {
     };
 };
 
-template<class T>
-struct sp_array_count<T[]> { };
-
-template<class D, class T>
-inline D*
-sp_get_deleter(const boost::shared_ptr<T>& value) BOOST_NOEXCEPT_OR_NOTHROW
-{
-    return static_cast<D*>(value._internal_get_untyped_deleter());
-}
-
-template<std::size_t N, std::size_t A>
-struct sp_array_storage {
-    union type {
-        char value[N];
-        typename boost::type_with_alignment<A>::type other;
-    };
-};
-
 template<std::size_t N, std::size_t M>
 struct sp_max_size {
     enum {
@@ -131,6 +113,13 @@ struct sp_max_size {
     };
 };
 
+template<std::size_t N, std::size_t M>
+struct sp_align_up {
+    enum {
+        value = (N + M - 1) & ~(M - 1)
+    };
+};
+
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
 template<class A, class T>
 struct sp_bind_allocator {
@@ -143,6 +132,13 @@ struct sp_bind_allocator {
 };
 #endif
 
+template<class T>
+BOOST_CONSTEXPR inline std::size_t
+sp_objects(std::size_t size) BOOST_SP_NOEXCEPT
+{
+    return (size + sizeof(T) - 1) / sizeof(T);
+}
+
 template<bool, class = void>
 struct sp_enable { };
 
@@ -151,13 +147,14 @@ struct sp_enable<true, T> {
     typedef T type;
 };
 
-template<class T>
-inline typename sp_enable<boost::has_trivial_destructor<T>::value>::type
-sp_array_destroy(T*, std::size_t) BOOST_SP_NOEXCEPT { }
+template<bool E, class A, class T>
+inline typename sp_enable<!E && boost::has_trivial_destructor<T>::value>::type
+sp_array_destroy(A&, T*, std::size_t) BOOST_SP_NOEXCEPT { }
 
-template<class T>
-inline typename sp_enable<!boost::has_trivial_destructor<T>::value>::type
-sp_array_destroy(T* storage, std::size_t size)
+template<bool E, class A, class T>
+inline typename sp_enable<!E &&
+    !boost::has_trivial_destructor<T>::value>::type
+sp_array_destroy(A&, T* storage, std::size_t size)
 {
     while (size > 0) {
         storage[--size].~T();
@@ -165,8 +162,8 @@ sp_array_destroy(T* storage, std::size_t size)
 }
 
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A, class T>
-inline void
+template<bool E, class A, class T>
+inline typename sp_enable<E>::type
 sp_array_destroy(A& allocator, T* storage, std::size_t size)
 {
     while (size > 0) {
@@ -176,20 +173,22 @@ sp_array_destroy(A& allocator, T* storage, std::size_t size)
 #endif
 
 #if !defined(BOOST_NO_EXCEPTIONS)
-template<class T>
-inline typename sp_enable<boost::has_trivial_constructor<T>::value ||
-    boost::has_trivial_destructor<T>::value>::type
-sp_array_construct(T* storage, std::size_t size)
+template<bool E, class A, class T>
+inline typename sp_enable<!E &&
+    (boost::has_trivial_constructor<T>::value ||
+    boost::has_trivial_destructor<T>::value)>::type
+sp_array_construct(A&, T* storage, std::size_t size)
 {
     for (std::size_t i = 0; i < size; ++i) {
         ::new(static_cast<void*>(storage + i)) T();
     }
 }
 
-template<class T>
-inline typename sp_enable<!boost::has_trivial_constructor<T>::value &&
+template<bool E, class A, class T>
+inline typename sp_enable<!E &&
+    !boost::has_trivial_constructor<T>::value &&
     !boost::has_trivial_destructor<T>::value>::type
-sp_array_construct(T* storage, std::size_t size)
+sp_array_construct(A& none, T* storage, std::size_t size)
 {
     std::size_t i = 0;
     try {
@@ -197,15 +196,16 @@ sp_array_construct(T* storage, std::size_t size)
             ::new(static_cast<void*>(storage + i)) T();
         }
     } catch (...) {
-        sp_array_destroy(storage, i);
+        sp_array_destroy<E>(none, storage, i);
         throw;
     }
 }
 
-template<class T>
-inline typename sp_enable<boost::has_trivial_copy_constructor<T>::value ||
-    boost::has_trivial_destructor<T>::value>::type
-sp_array_construct(T* storage, std::size_t size, const T* list,
+template<bool E, class A, class T>
+inline typename sp_enable<!E &&
+    (boost::has_trivial_copy_constructor<T>::value ||
+    boost::has_trivial_destructor<T>::value)>::type
+sp_array_construct(A&, T* storage, std::size_t size, const T* list,
     std::size_t count)
 {
     for (std::size_t i = 0; i < size; ++i) {
@@ -213,10 +213,11 @@ sp_array_construct(T* storage, std::size_t size, const T* list,
     }
 }
 
-template<class T>
-inline typename sp_enable<!boost::has_trivial_copy_constructor<T>::value &&
+template<bool E, class A, class T>
+inline typename sp_enable<!E &&
+    !boost::has_trivial_copy_constructor<T>::value &&
     !boost::has_trivial_destructor<T>::value>::type
-sp_array_construct(T* storage, std::size_t size, const T* list,
+sp_array_construct(A& none, T* storage, std::size_t size, const T* list,
     std::size_t count)
 {
     std::size_t i = 0;
@@ -225,23 +226,23 @@ sp_array_construct(T* storage, std::size_t size, const T* list,
             ::new(static_cast<void*>(storage + i)) T(list[i % count]);
         }
     } catch (...) {
-        sp_array_destroy(storage, i);
+        sp_array_destroy<E>(none, storage, i);
         throw;
     }
 }
 #else
-template<class T>
-inline void
-sp_array_construct(T* storage, std::size_t size)
+template<bool E, class A, class T>
+inline typename sp_enable<!E>::type
+sp_array_construct(A&, T* storage, std::size_t size)
 {
     for (std::size_t i = 0; i < size; ++i) {
         ::new(static_cast<void*>(storage + i)) T();
     }
 }
 
-template<class T>
-inline void
-sp_array_construct(T* storage, std::size_t size, const T* list,
+template<bool E, class A, class T>
+inline typename sp_enable<!E>::type
+sp_array_construct(A&, T* storage, std::size_t size, const T* list,
     std::size_t count)
 {
     for (std::size_t i = 0; i < size; ++i) {
@@ -252,8 +253,8 @@ sp_array_construct(T* storage, std::size_t size, const T* list,
 
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
 #if !defined(BOOST_NO_EXCEPTIONS)
-template<class A, class T>
-inline void
+template<bool E, class A, class T>
+inline typename sp_enable<E>::type
 sp_array_construct(A& allocator, T* storage, std::size_t size)
 {
     std::size_t i = 0;
@@ -262,13 +263,13 @@ sp_array_construct(A& allocator, T* storage, std::size_t size)
             std::allocator_traits<A>::construct(allocator, storage + i);
         }
     } catch (...) {
-        sp_array_destroy(allocator, storage, i);
+        sp_array_destroy<E>(allocator, storage, i);
         throw;
     }
 }
 
-template<class A, class T>
-inline void
+template<bool E, class A, class T>
+inline typename sp_enable<E>::type
 sp_array_construct(A& allocator, T* storage, std::size_t size,
     const T* list, std::size_t count)
 {
@@ -279,13 +280,13 @@ sp_array_construct(A& allocator, T* storage, std::size_t size,
                 list[i % count]);
         }
     } catch (...) {
-        sp_array_destroy(allocator, storage, i);
+        sp_array_destroy<E>(allocator, storage, i);
         throw;
     }
 }
 #else
-template<class A, class T>
-inline void
+template<bool E, class A, class T>
+inline typename sp_enable<E>::type
 sp_array_construct(A& allocator, T* storage, std::size_t size)
 {
     for (std::size_t i = 0; i < size; ++i) {
@@ -293,8 +294,8 @@ sp_array_construct(A& allocator, T* storage, std::size_t size)
     }
 }
 
-template<class A, class T>
-inline void
+template<bool E, class A, class T>
+inline typename sp_enable<E>::type
 sp_array_construct(A& allocator, T* storage, std::size_t size,
     const T* list, std::size_t count)
 {
@@ -306,25 +307,25 @@ sp_array_construct(A& allocator, T* storage, std::size_t size,
 #endif
 #endif
 
-template<class T>
+template<class A, class T>
 inline typename sp_enable<boost::has_trivial_constructor<T>::value>::type
-sp_array_default(T*, std::size_t) BOOST_SP_NOEXCEPT { }
+sp_array_default(A&, T*, std::size_t) BOOST_SP_NOEXCEPT { }
 
 #if !defined(BOOST_NO_EXCEPTIONS)
-template<class T>
+template<class A, class T>
 inline typename sp_enable<!boost::has_trivial_constructor<T>::value &&
     boost::has_trivial_destructor<T>::value>::type
-sp_array_default(T* storage, std::size_t size)
+sp_array_default(A&, T* storage, std::size_t size)
 {
     for (std::size_t i = 0; i < size; ++i) {
         ::new(static_cast<void*>(storage + i)) T;
     }
 }
 
-template<class T>
+template<class A, class T>
 inline typename sp_enable<!boost::has_trivial_constructor<T>::value &&
     !boost::has_trivial_destructor<T>::value>::type
-sp_array_default(T* storage, std::size_t size)
+sp_array_default(A& none, T* storage, std::size_t size)
 {
     std::size_t i = 0;
     try {
@@ -332,14 +333,14 @@ sp_array_default(T* storage, std::size_t size)
             ::new(static_cast<void*>(storage + i)) T;
         }
     } catch (...) {
-        sp_array_destroy(storage, i);
+        sp_array_destroy<false>(none, storage, i);
         throw;
     }
 }
 #else
-template<class T>
+template<bool E, class A, class T>
 inline typename sp_enable<!boost::has_trivial_constructor<T>::value>::type
-sp_array_default(T* storage, std::size_t size)
+sp_array_default(A&, T* storage, std::size_t size)
 {
     for (std::size_t i = 0; i < size; ++i) {
         ::new(static_cast<void*>(storage + i)) T;
@@ -347,650 +348,260 @@ sp_array_default(T* storage, std::size_t size)
 }
 #endif
 
-template<class T, std::size_t N>
-struct sp_less_align {
+template<class A>
+class sp_array_state {
+public:
+    typedef A type;
+
+    sp_array_state(const A& allocator, std::size_t size) BOOST_SP_NOEXCEPT
+        : allocator_(allocator),
+          size_(size) { }
+
+    A& allocator() BOOST_SP_NOEXCEPT {
+        return allocator_;
+    }
+
+    std::size_t size() const BOOST_SP_NOEXCEPT {
+        return size_;
+    }
+
+private:
+    A allocator_;
+    std::size_t size_;
+};
+
+template<class A, std::size_t N>
+class sp_size_array_state {
+public:
+    typedef A type;
+
+    sp_size_array_state(const A& allocator, std::size_t) BOOST_SP_NOEXCEPT
+        : allocator_(allocator) { }
+
+    A& allocator() BOOST_SP_NOEXCEPT {
+        return allocator_;
+    }
+
+    BOOST_CONSTEXPR std::size_t size() const BOOST_SP_NOEXCEPT {
+        return N;
+    }
+
+private:
+    A allocator_;
+};
+
+#if !defined(BOOST_NO_CXX11_ALLOCATOR)
+template<class A>
+struct sp_use_construct {
     enum {
-        value = (boost::alignment_of<T>::value) < N
+        value = true
     };
 };
 
-template<class T, std::size_t N>
-BOOST_CONSTEXPR
-inline typename sp_enable<sp_less_align<T, N>::value, std::size_t>::type
-sp_align(std::size_t size) BOOST_SP_NOEXCEPT
-{
-    return (sizeof(T) * size + N - 1) & ~(N - 1);
-}
-
-template<class T, std::size_t N>
-BOOST_CONSTEXPR
-inline typename sp_enable<!sp_less_align<T, N>::value, std::size_t>::type
-sp_align(std::size_t size) BOOST_SP_NOEXCEPT
-{
-    return sizeof(T) * size;
-}
-
 template<class T>
-BOOST_CONSTEXPR inline std::size_t
-sp_types(std::size_t size) BOOST_SP_NOEXCEPT
-{
-    return (size + sizeof(T) - 1) / sizeof(T);
-}
-
-template<class T, std::size_t N>
-class sp_size_array_deleter {
-public:
-    template<class U>
-    static void operator_fn(U) BOOST_SP_NOEXCEPT { }
-
-    sp_size_array_deleter() BOOST_SP_NOEXCEPT
-        : enabled_(false) { }
-
-    template<class A>
-    sp_size_array_deleter(const A&) BOOST_SP_NOEXCEPT
-        : enabled_(false) { }
-
-    sp_size_array_deleter(const sp_size_array_deleter&) BOOST_SP_NOEXCEPT
-        : enabled_(false) { }
-
-    ~sp_size_array_deleter() {
-        if (enabled_) {
-            sp_array_destroy(reinterpret_cast<T*>(&storage_), N);
-        }
-    }
-
-    template<class U>
-    void operator()(U) {
-        if (enabled_) {
-            sp_array_destroy(reinterpret_cast<T*>(&storage_), N);
-            enabled_ = false;
-        }
-    }
-
-    void* construct() {
-        sp_array_construct(reinterpret_cast<T*>(&storage_), N);
-        enabled_ = true;
-        return &storage_;
-    }
-
-    void* construct(const T* list, std::size_t count) {
-        sp_array_construct(reinterpret_cast<T*>(&storage_), N, list, count);
-        enabled_ = true;
-        return &storage_;
-    }
-
-    void* construct_default() {
-        sp_array_default(reinterpret_cast<T*>(&storage_), N);
-        enabled_ = true;
-        return &storage_;
-    }
-
-private:
-    bool enabled_;
-    typename sp_array_storage<sizeof(T) * N,
-        boost::alignment_of<T>::value>::type storage_;
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T, std::size_t N, class A>
-class sp_size_array_destroyer {
-public:
-    template<class U>
-    static void operator_fn(U) BOOST_SP_NOEXCEPT { }
-
-    template<class U>
-    sp_size_array_destroyer(const U& allocator) BOOST_SP_NOEXCEPT
-        : allocator_(allocator),
-          enabled_(false) { }
-
-    sp_size_array_destroyer(const sp_size_array_destroyer& other)
-        BOOST_SP_NOEXCEPT
-        : allocator_(other.allocator_),
-          enabled_(false) { }
-
-    ~sp_size_array_destroyer() {
-        if (enabled_) {
-            sp_array_destroy(allocator_, reinterpret_cast<T*>(&storage_), N);
-        }
-    }
-
-    template<class U>
-    void operator()(U) {
-        if (enabled_) {
-            sp_array_destroy(allocator_, reinterpret_cast<T*>(&storage_), N);
-            enabled_ = false;
-        }
-    }
-
-    void* construct() {
-        sp_array_construct(allocator_, reinterpret_cast<T*>(&storage_), N);
-        enabled_ = true;
-        return &storage_;
-    }
-
-    void* construct(const T* list, std::size_t count) {
-        sp_array_construct(allocator_, reinterpret_cast<T*>(&storage_), N,
-            list, count);
-        enabled_ = true;
-        return &storage_;
-    }
-
-    const A& allocator() const BOOST_SP_NOEXCEPT {
-        return allocator_;
-    }
-
-private:
-    typename sp_array_storage<sizeof(T) * N,
-        boost::alignment_of<T>::value>::type storage_;
-    A allocator_;
-    bool enabled_;
-};
-#endif
-
-template<class T>
-class sp_array_deleter {
-public:
-    template<class U>
-    static void operator_fn(U) BOOST_SP_NOEXCEPT { }
-
-    sp_array_deleter(std::size_t size) BOOST_SP_NOEXCEPT
-        : address_(0),
-          size_(size) { }
-
-    template<class A>
-    sp_array_deleter(const A& allocator) BOOST_SP_NOEXCEPT
-        : address_(0),
-          size_(allocator.size()) { }
-
-    template<class A>
-    sp_array_deleter(const A&, std::size_t size) BOOST_SP_NOEXCEPT
-        : address_(0),
-          size_(size) { }
-
-    sp_array_deleter(const sp_array_deleter& other) BOOST_SP_NOEXCEPT
-        : address_(0),
-          size_(other.size_) { }
-
-    ~sp_array_deleter() {
-        if (address_) {
-            sp_array_destroy(static_cast<T*>(address_), size_);
-        }
-    }
-
-    template<class U>
-    void operator()(U) {
-        if (address_) {
-            sp_array_destroy(static_cast<T*>(address_), size_);
-            address_ = 0;
-        }
-    }
-
-    void construct(T* address) {
-        sp_array_construct(address, size_);
-        address_ = address;
-    }
-
-    void construct(T* address, const T* list, std::size_t count) {
-        sp_array_construct(address, size_, list, count);
-        address_ = address;
-    }
-
-    void construct_default(T* address) {
-        sp_array_default(address, size_);
-        address_ = address;
-    }
-
-    std::size_t size() const BOOST_SP_NOEXCEPT {
-        return size_;
-    }
-
-private:
-    void* address_;
-    std::size_t size_;
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class T, class A>
-class sp_array_destroyer {
-public:
-    template<class U>
-    static void operator_fn(U) BOOST_SP_NOEXCEPT { }
-
-    template<class U>
-    sp_array_destroyer(const U& allocator, std::size_t size) BOOST_SP_NOEXCEPT
-        : allocator_(allocator),
-          size_(size),
-          address_(0) { }
-
-    template<class U>
-    sp_array_destroyer(const U& allocator) BOOST_SP_NOEXCEPT
-        : allocator_(allocator.allocator()),
-          size_(allocator.size()),
-          address_(0) { }
-
-    sp_array_destroyer(const sp_array_destroyer& other) BOOST_SP_NOEXCEPT
-        : allocator_(other.allocator_),
-          size_(other.size_),
-          address_(0) { }
-
-    ~sp_array_destroyer() {
-        if (address_) {
-            sp_array_destroy(allocator_, static_cast<T*>(address_), size_);
-        }
-    }
-
-    template<class U>
-    void operator()(U) {
-        if (address_) {
-            sp_array_destroy(allocator_, static_cast<T*>(address_), size_);
-            address_ = 0;
-        }
-    }
-
-    void construct(T* address) {
-        sp_array_construct(allocator_, address, size_);
-        address_ = address;
-    }
-
-    void construct(T* address, const T* list, std::size_t count) {
-        sp_array_construct(allocator_, address, size_, list, count);
-        address_ = address;
-    }
-
-    const A& allocator() const BOOST_SP_NOEXCEPT {
-        return allocator_;
-    }
-
-    std::size_t size() const BOOST_SP_NOEXCEPT {
-        return size_;
-    }
-
-private:
-    A allocator_;
-    std::size_t size_;
-    void* address_;
-};
-#endif
-
-template<class T, class A>
-class sp_array_allocator {
-    template<class U, class V>
-    friend class sp_array_allocator;
-
-public:
-    typedef typename A::value_type value_type;
-
-private:
+struct sp_use_construct<std::allocator<T> > {
     enum {
-        alignment = sp_max_size<boost::alignment_of<T>::value,
-            boost::alignment_of<value_type>::value>::value
+        value = false
+    };
+};
+#else
+template<class>
+struct sp_use_construct {
+    enum {
+        value = false
+    };
+};
+#endif
+
+template<class T, class U>
+struct sp_array_alignment {
+    enum {
+        value = sp_max_size<boost::alignment_of<T>::value,
+            boost::alignment_of<U>::value>::value
+    };
+};
+
+template<class T, class U>
+struct sp_array_offset {
+    enum {
+        value = sp_align_up<sizeof(T), sp_array_alignment<T, U>::value>::value
+    };
+};
+
+template<class T, class U>
+inline T*
+sp_array_start(U* base) BOOST_SP_NOEXCEPT
+{
+    enum {
+        size = sp_array_offset<U, T>::value
+    };
+    return reinterpret_cast<T*>(reinterpret_cast<char*>(base) + size);
+}
+
+template<class A, class T>
+class sp_array_creator {
+    typedef typename A::value_type scalar;
+
+    enum {
+        alignment = sp_array_alignment<T, scalar>::value
+    };
+    enum {
+        offset = sp_array_offset<T, scalar>::value
     };
 
     typedef typename boost::type_with_alignment<alignment>::type type;
-    typedef typename sp_bind_allocator<A, type>::type type_allocator;
 
 public:
     template<class U>
-    struct rebind {
-        typedef sp_array_allocator<T,
-            typename sp_bind_allocator<A, U>::type> other;
-    };
+    sp_array_creator(const U& other, std::size_t size) BOOST_SP_NOEXCEPT
+        : other_(other),
+          size_(sp_objects<type>(offset + sizeof(scalar) * size)) { }
 
-    sp_array_allocator(const A& allocator, std::size_t size, void** result)
-        BOOST_SP_NOEXCEPT
-        : allocator_(allocator),
-          size_(size),
-          result_(result) { }
-
-    sp_array_allocator(const A& allocator, std::size_t size) BOOST_SP_NOEXCEPT
-        : allocator_(allocator),
-          size_(size) { }
-
-    template<class U>
-    sp_array_allocator(const sp_array_allocator<T, U>& other)
-        BOOST_SP_NOEXCEPT
-        : allocator_(other.allocator_),
-          size_(other.size_),
-          result_(other.result_) { }
-
-    value_type* allocate(std::size_t count) {
-        type_allocator allocator(allocator_);
-        std::size_t node = sp_align<value_type, alignment>(count);
-        std::size_t size = sp_types<type>(node + sizeof(T) * size_);
-        type* address = allocator.allocate(size);
-        *result_ = reinterpret_cast<char*>(address) + node;
-        return reinterpret_cast<value_type*>(address);
+    T* create() {
+        return reinterpret_cast<T*>(other_.allocate(size_));
     }
 
-    void deallocate(value_type* value, std::size_t count) {
-        type_allocator allocator(allocator_);
-        std::size_t node = sp_align<value_type, alignment>(count);
-        std::size_t size = sp_types<type>(node + sizeof(T) * size_);
-        allocator.deallocate(reinterpret_cast<type*>(value), size);
-    }
-
-    const A& allocator() const BOOST_SP_NOEXCEPT {
-        return allocator_;
-    }
-
-    std::size_t size() const BOOST_SP_NOEXCEPT {
-        return size_;
+    void destroy(T* base) {
+        other_.deallocate(reinterpret_cast<type*>(base), size_);
     }
 
 private:
-    A allocator_;
+    typename sp_bind_allocator<A, type>::type other_;
     std::size_t size_;
-    void** result_;
 };
 
-template<class T, class U, class V>
-inline bool
-operator==(const sp_array_allocator<T, U>& first,
-    const sp_array_allocator<T, V>& second) BOOST_SP_NOEXCEPT
-{
-    return first.allocator() == second.allocator() &&
-        first.size() == second.size();
-}
+struct sp_default { };
 
-template<class T, class U, class V>
-inline bool
-operator!=(const sp_array_allocator<T, U>& first,
-    const sp_array_allocator<T, V>& second) BOOST_SP_NOEXCEPT
-{
-    return !(first == second);
-}
+template<class T, bool E = sp_use_construct<T>::value>
+class sp_array_base
+    : public sp_counted_base {
+    typedef typename T::type allocator;
 
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class A, class T, std::size_t N>
-struct sp_select_size_deleter {
-    typedef sp_size_array_destroyer<T, N,
-        typename sp_bind_allocator<A, T>::type> type;
-};
+public:
+    typedef typename allocator::value_type type;
 
-template<class U, class T, std::size_t N>
-struct sp_select_size_deleter<std::allocator<U>, T, N> {
-    typedef sp_size_array_deleter<T, N> type;
+    template<class A>
+    sp_array_base(const A& other, std::size_t size)
+        : state_(other, size) {
+        sp_array_construct<E>(state_.allocator(), sp_array_start<type>(this),
+            state_.size());
+    }
+
+    template<class A>
+    sp_array_base(const A& other, std::size_t size, const type* list,
+        std::size_t count)
+        : state_(other, size) {
+        sp_array_construct<E>(state_.allocator(), sp_array_start<type>(this),
+            state_.size(), list, count);
+    }
+
+    template<class A>
+    sp_array_base(sp_default, const A& other, std::size_t size)
+        : state_(other, size) {
+        sp_array_default(state_.allocator(), sp_array_start<type>(this),
+            state_.size());
+    }
+
+    virtual void dispose() {
+        sp_array_destroy<E>(state_.allocator(), sp_array_start<type>(this),
+            state_.size());
+    }
+
+    virtual void destroy() {
+        sp_array_creator<allocator, sp_array_base> other(state_.allocator(),
+            state_.size());
+        this->~sp_array_base();
+        other.destroy(this);
+    }
+
+    virtual void* get_deleter(const sp_typeinfo&) {
+        return 0;
+    }
+
+    virtual void* get_local_deleter(const sp_typeinfo&) {
+        return 0;
+    }
+
+    virtual void* get_untyped_deleter() {
+        return 0;
+    }
+
+private:
+    T state_;
 };
 
 template<class A, class T>
-struct sp_select_deleter {
-    typedef sp_array_destroyer<T,
-        typename sp_bind_allocator<A, T>::type> type;
-};
-
-template<class U, class T>
-struct sp_select_deleter<std::allocator<U>, T> {
-    typedef sp_array_deleter<T> type;
-};
-#else
-template<class, class T, std::size_t N>
-struct sp_select_size_deleter {
-    typedef sp_size_array_deleter<T, N> type;
-};
-
-template<class, class T>
-struct sp_select_deleter {
-    typedef sp_array_deleter<T> type;
-};
-#endif
-
-template<class P, class T, std::size_t N, class A>
-class sp_counted_impl_pda<P, sp_size_array_deleter<T, N>, A>
-    : public sp_counted_base {
+struct sp_array_result {
 public:
-    typedef sp_size_array_deleter<T, N> deleter_type;
+    template<class U>
+    sp_array_result(const U& other, std::size_t size)
+        : creator_(other, size),
+          result_(creator_.create()) { }
 
-private:
-    typedef sp_counted_impl_pda<P, deleter_type, A> type;
-    typedef typename sp_bind_allocator<A, type>::type deallocator;
-
-public:
-    sp_counted_impl_pda(P, const deleter_type&, const A& allocator)
-        : deleter_(allocator),
-          allocator_(allocator) { }
-
-    sp_counted_impl_pda(P, const A& allocator)
-        : deleter_(allocator) { }
-
-    void dispose() {
-        deleter_(0);
+    ~sp_array_result() {
+        if (result_) {
+            creator_.destroy(result_);
+        }
     }
 
-    void destroy() {
-        deallocator allocator(allocator_);
-        this->~type();
-        allocator.deallocate(this, 1);
+    T* get() const {
+        return result_;
     }
 
-    void* get_deleter(const sp_typeinfo& info) {
-        return info == BOOST_SP_TYPEID(deleter_type) ?
-            &reinterpret_cast<char&>(deleter_) : 0;
-    }
-
-    void* get_local_deleter(const sp_typeinfo&) {
-        return 0;
-    }
-
-    void* get_untyped_deleter() {
-        return &reinterpret_cast<char&>(deleter_);
+    T* release() {
+        T* value = result_;
+        result_ = 0;
+        return value;
     }
 
 private:
-    deleter_type deleter_;
-    A allocator_;
+    sp_array_result(const sp_array_result&);
+    sp_array_result& operator=(const sp_array_result&);
+
+    sp_array_creator<A, T> creator_;
+    T* result_;
 };
 
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class P, class T, std::size_t N, class U, class A>
-class sp_counted_impl_pda<P, sp_size_array_destroyer<T, N, U>, A>
-    : public sp_counted_base {
-public:
-    typedef sp_size_array_destroyer<T, N, U> deleter_type;
-
-private:
-    typedef sp_counted_impl_pda<P, deleter_type, A> type;
-    typedef typename sp_bind_allocator<A, type>::type deallocator;
-
-public:
-    sp_counted_impl_pda(P, const deleter_type&, const A& allocator)
-        : deleter_(allocator) { }
-
-    sp_counted_impl_pda(P, const A& allocator)
-        : deleter_(allocator) { }
-
-    void dispose() {
-        deleter_(0);
-    }
-
-    void destroy() {
-        deallocator allocator(deleter_.allocator());
-        this->~type();
-        allocator.deallocate(this, 1);
-    }
-
-    void* get_deleter(const sp_typeinfo& info) {
-        return info == BOOST_SP_TYPEID(deleter_type) ?
-            &reinterpret_cast<char&>(deleter_) : 0;
-    }
-
-    void* get_local_deleter(const sp_typeinfo&) {
-        return 0;
-    }
-
-    void* get_untyped_deleter() {
-        return &reinterpret_cast<char&>(deleter_);
-    }
-
-private:
-    deleter_type deleter_;
-};
-#endif
-
-template<class P, class T, class A>
-class sp_counted_impl_pda<P, sp_array_deleter<T>,
-    sp_array_allocator<T, A> >
-    : public sp_counted_base {
-public:
-    typedef sp_array_deleter<T> deleter_type;
-    typedef sp_array_allocator<T, A> allocator_type;
-
-private:
-    typedef sp_counted_impl_pda<P, deleter_type, allocator_type> type;
-    typedef sp_array_allocator<T,
-        typename sp_bind_allocator<A, type>::type> deallocator;
-
-public:
-    sp_counted_impl_pda(P, const deleter_type&,
-        const allocator_type& allocator)
-        : deleter_(allocator),
-          allocator_(allocator.allocator()) { }
-
-    sp_counted_impl_pda(P, const allocator_type& allocator)
-        : deleter_(allocator),
-          allocator_(allocator.allocator()) { }
-
-    void dispose() {
-        deleter_(0);
-    }
-
-    void destroy() {
-        deallocator allocator(allocator_, deleter_.size());
-        this->~type();
-        allocator.deallocate(this, 1);
-    }
-
-    void* get_deleter(const sp_typeinfo& info) {
-        return info == BOOST_SP_TYPEID(deleter_type) ?
-            &reinterpret_cast<char&>(deleter_) : 0;
-    }
-
-    void* get_local_deleter(const sp_typeinfo&) {
-        return 0;
-    }
-
-    void* get_untyped_deleter() {
-        return &reinterpret_cast<char&>(deleter_);
-    }
-
-private:
-    deleter_type deleter_;
-    A allocator_;
-};
-
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-template<class P, class T, class U, class A>
-class sp_counted_impl_pda<P, sp_array_destroyer<T, U>,
-    sp_array_allocator<T, A> >
-    : public sp_counted_base {
-public:
-    typedef sp_array_destroyer<T, U> deleter_type;
-    typedef sp_array_allocator<T, A> allocator_type;
-
-private:
-    typedef sp_counted_impl_pda<P, deleter_type, allocator_type> type;
-    typedef sp_array_allocator<T,
-        typename sp_bind_allocator<A, type>::type> deallocator;
-
-public:
-    sp_counted_impl_pda(P, const deleter_type&,
-        const allocator_type& allocator)
-        : deleter_(allocator) { }
-
-    sp_counted_impl_pda(P, const allocator_type& allocator)
-        : deleter_(allocator) { }
-
-    void dispose() {
-        deleter_(0);
-    }
-
-    void destroy() {
-        deallocator allocator(deleter_.allocator(), deleter_.size());
-        this->~type();
-        allocator.deallocate(this, 1);
-    }
-
-    void* get_deleter(const sp_typeinfo& info) {
-        return info == BOOST_SP_TYPEID(deleter_type) ?
-            &reinterpret_cast<char&>(deleter_) : 0;
-    }
-
-    void* get_local_deleter(const sp_typeinfo&) {
-        return 0;
-    }
-
-    void* get_untyped_deleter() {
-        return &reinterpret_cast<char&>(deleter_);
-    }
-
-private:
-    deleter_type deleter_;
-};
-#endif
-
 } /* detail */
 
-template<class T, class A>
-inline typename detail::sp_if_size_array<T>::type
-allocate_shared(const A& allocator)
-{
-    typedef typename detail::sp_array_element<T>::type type;
-    typedef typename detail::sp_array_scalar<T>::type scalar;
-    typedef typename detail::sp_select_size_deleter<A, scalar,
-        detail::sp_array_count<T>::value>::type deleter;
-    shared_ptr<T> result(static_cast<type*>(0),
-        detail::sp_inplace_tag<deleter>(), allocator);
-    deleter* state = detail::sp_get_deleter<deleter>(result);
-    void* start = state->construct();
-    return shared_ptr<T>(result, static_cast<type*>(start));
-}
-
-template<class T, class A>
-inline typename detail::sp_if_size_array<T>::type
-allocate_shared(const A& allocator,
-    const typename detail::sp_array_element<T>::type& value)
-{
-    typedef typename detail::sp_array_element<T>::type type;
-    typedef typename detail::sp_array_scalar<T>::type scalar;
-    typedef typename detail::sp_select_size_deleter<A, scalar,
-        detail::sp_array_count<T>::value>::type deleter;
-    shared_ptr<T> result(static_cast<type*>(0),
-        detail::sp_inplace_tag<deleter>(), allocator);
-    deleter* state = detail::sp_get_deleter<deleter>(result);
-    void* start = state->construct(reinterpret_cast<const scalar*>(&value),
-        detail::sp_array_count<type>::value);
-    return shared_ptr<T>(result, static_cast<type*>(start));
-}
-
-template<class T, class A>
-inline typename detail::sp_if_size_array<T>::type
-allocate_shared_noinit(const A& allocator)
-{
-    typedef typename detail::sp_array_element<T>::type type;
-    typedef typename detail::sp_array_scalar<T>::type scalar;
-    typedef detail::sp_size_array_deleter<scalar,
-        detail::sp_array_count<T>::value> deleter;
-    shared_ptr<T> result(static_cast<type*>(0),
-        detail::sp_inplace_tag<deleter>(), allocator);
-    deleter* state = detail::sp_get_deleter<deleter>(result);
-    void* start = state->construct_default();
-    return shared_ptr<T>(result, static_cast<type*>(start));
-}
-
 template<class T, class A>
 inline typename detail::sp_if_array<T>::type
 allocate_shared(const A& allocator, std::size_t count)
 {
     typedef typename detail::sp_array_element<T>::type type;
     typedef typename detail::sp_array_scalar<T>::type scalar;
-    typedef typename detail::sp_select_deleter<A, scalar>::type deleter;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    typedef detail::sp_array_state<other> state;
+    typedef detail::sp_array_base<state> base;
     std::size_t size = count * detail::sp_array_count<type>::value;
-    void* start;
-    shared_ptr<T> result(static_cast<type*>(0),
-        detail::sp_inplace_tag<deleter>(),
-        detail::sp_array_allocator<scalar, A>(allocator, size, &start));
-    deleter* state = detail::sp_get_deleter<deleter>(result);
-    state->construct(static_cast<scalar*>(start));
-    return shared_ptr<T>(result, static_cast<type*>(start));
+    detail::sp_array_result<other, base> result(allocator, size);
+    base* node = result.get();
+    ::new(static_cast<void*>(node)) base(allocator, size);
+    void* start = detail::sp_array_start<scalar>(node);
+    detail::sp_counted_base* next = result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
+        static_cast<type*>(start), detail::shared_count(next));
+}
+
+template<class T, class A>
+inline typename detail::sp_if_size_array<T>::type
+allocate_shared(const A& allocator)
+{
+    typedef typename detail::sp_array_element<T>::type type;
+    typedef typename detail::sp_array_scalar<T>::type scalar;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    enum {
+        size = detail::sp_array_count<T>::value
+    };
+    typedef detail::sp_size_array_state<other, size> state;
+    typedef detail::sp_array_base<state> base;
+    detail::sp_array_result<other, base> result(allocator, size);
+    base* node = result.get();
+    ::new(static_cast<void*>(node)) base(allocator, size);
+    void* start = detail::sp_array_start<scalar>(node);
+    detail::sp_counted_base* next = result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
+        static_cast<type*>(start), detail::shared_count(next));
 }
 
 template<class T, class A>
@@ -1000,17 +611,43 @@ allocate_shared(const A& allocator, std::size_t count,
 {
     typedef typename detail::sp_array_element<T>::type type;
     typedef typename detail::sp_array_scalar<T>::type scalar;
-    typedef typename detail::sp_select_deleter<A, scalar>::type deleter;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    typedef detail::sp_array_state<other> state;
+    typedef detail::sp_array_base<state> base;
     std::size_t size = count * detail::sp_array_count<type>::value;
-    void* start;
-    shared_ptr<T> result(static_cast<type*>(0),
-        detail::sp_inplace_tag<deleter>(),
-        detail::sp_array_allocator<scalar, A>(allocator, size, &start));
-    deleter* state = detail::sp_get_deleter<deleter>(result);
-    state->construct(static_cast<scalar*>(start),
+    detail::sp_array_result<other, base> result(allocator, size);
+    base* node = result.get();
+    ::new(static_cast<void*>(node)) base(allocator, size,
         reinterpret_cast<const scalar*>(&value),
         detail::sp_array_count<type>::value);
-    return shared_ptr<T>(result, static_cast<type*>(start));
+    void* start = detail::sp_array_start<scalar>(node);
+    detail::sp_counted_base* next = result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
+        static_cast<type*>(start), detail::shared_count(next));
+}
+
+template<class T, class A>
+inline typename detail::sp_if_size_array<T>::type
+allocate_shared(const A& allocator,
+    const typename detail::sp_array_element<T>::type& value)
+{
+    typedef typename detail::sp_array_element<T>::type type;
+    typedef typename detail::sp_array_scalar<T>::type scalar;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    enum {
+        size = detail::sp_array_count<T>::value
+    };
+    typedef detail::sp_size_array_state<other, size> state;
+    typedef detail::sp_array_base<state> base;
+    detail::sp_array_result<other, base> result(allocator, size);
+    base* node = result.get();
+    ::new(static_cast<void*>(node)) base(allocator, size,
+        reinterpret_cast<const scalar*>(&value),
+        detail::sp_array_count<type>::value);
+    void* start = detail::sp_array_start<scalar>(node);
+    detail::sp_counted_base* next = result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
+        static_cast<type*>(start), detail::shared_count(next));
 }
 
 template<class T, class A>
@@ -1019,15 +656,40 @@ allocate_shared_noinit(const A& allocator, std::size_t count)
 {
     typedef typename detail::sp_array_element<T>::type type;
     typedef typename detail::sp_array_scalar<T>::type scalar;
-    typedef detail::sp_array_deleter<scalar> deleter;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    typedef detail::sp_array_state<other> state;
+    typedef detail::sp_array_base<state, false> base;
     std::size_t size = count * detail::sp_array_count<type>::value;
-    void* start;
-    shared_ptr<T> result(static_cast<type*>(0),
-        detail::sp_inplace_tag<deleter>(),
-        detail::sp_array_allocator<scalar, A>(allocator, size, &start));
-    deleter* state = detail::sp_get_deleter<deleter>(result);
-    state->construct_default(static_cast<scalar*>(start));
-    return shared_ptr<T>(result, static_cast<type*>(start));
+    detail::sp_array_result<other, base> result(allocator, size);
+    base* node = result.get();
+    ::new(static_cast<void*>(node)) base(detail::sp_default(),
+        allocator, size);
+    void* start = detail::sp_array_start<scalar>(node);
+    detail::sp_counted_base* next = result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
+        static_cast<type*>(start), detail::shared_count(next));
+}
+
+template<class T, class A>
+inline typename detail::sp_if_size_array<T>::type
+allocate_shared_noinit(const A& allocator)
+{
+    typedef typename detail::sp_array_element<T>::type type;
+    typedef typename detail::sp_array_scalar<T>::type scalar;
+    typedef typename detail::sp_bind_allocator<A, scalar>::type other;
+    enum {
+        size = detail::sp_array_count<T>::value
+    };
+    typedef detail::sp_size_array_state<other, size> state;
+    typedef detail::sp_array_base<state, false> base;
+    detail::sp_array_result<other, base> result(allocator, size);
+    base* node = result.get();
+    ::new(static_cast<void*>(node)) base(detail::sp_default(),
+        allocator, size);
+    void* start = detail::sp_array_start<scalar>(node);
+    detail::sp_counted_base* next = result.release();
+    return shared_ptr<T>(detail::sp_internal_constructor_tag(),
+        static_cast<type*>(start), detail::shared_count(next));
 }
 
 } /* boost */