From c28bef2e9b12d2aea0437b52c0198a161f391306 Mon Sep 17 00:00:00 2001
From: Glen Fernandes <glenfe@live.com>
Date: Wed, 12 Dec 2012 22:57:03 +0000
Subject: [PATCH] Merged revision(s) 81858,81859,81865,81867 from trunk: Add
 overloads of allocate_shared_noinit to complement make_shared_noinit ........
 Explicitly name detail array construct overloads for different parameter
 types. ........ Use _internal_get_untyped_deleter in allocate_shared_array
 and make_shared_array ........ Documentation corrections:
 make_shared_array.html ........

[SVN r81882]
---
 .../boost/smart_ptr/allocate_shared_array.hpp | 112 ++++++++++++------
 .../boost/smart_ptr/detail/array_deleter.hpp  |   8 +-
 .../boost/smart_ptr/detail/array_utility.hpp  |   4 +-
 include/boost/smart_ptr/make_shared_array.hpp |  90 +++++++-------
 make_shared_array.html                        |  18 ++-
 test/allocate_shared_array_esft_test.cpp      |  10 ++
 test/allocate_shared_array_test.cpp           |  74 ++++++++++++
 test/allocate_shared_array_throws_test.cpp    |  14 +++
 test/allocate_shared_arrays_test.cpp          |  56 +++++++++
 9 files changed, 293 insertions(+), 93 deletions(-)

diff --git a/include/boost/smart_ptr/allocate_shared_array.hpp b/include/boost/smart_ptr/allocate_shared_array.hpp
index dc24ca2..7f78d0e 100644
--- a/include/boost/smart_ptr/allocate_shared_array.hpp
+++ b/include/boost/smart_ptr/allocate_shared_array.hpp
@@ -1,9 +1,9 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes 
+ * Copyright (c) 2012 Glen Joseph Fernandes
  * glenfe at live dot com
  *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
+ * Distributed under the Boost Software License,
+ * Version 1.0. (See accompanying file LICENSE_1_0.txt
  * or copy at http://boost.org/LICENSE_1_0.txt)
  */
 #ifndef BOOST_SMART_PTR_ALLOCATE_SHARED_ARRAY_HPP
@@ -20,7 +20,7 @@
 
 namespace boost {
     template<typename T, typename A>
-    inline typename boost::detail::sp_if_array<T>::type 
+    inline typename boost::detail::sp_if_array<T>::type
     allocate_shared(const A& allocator, std::size_t size) {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
@@ -30,9 +30,9 @@ namespace boost {
         boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
         boost::detail::array_deleter<T2[]> d1(n1);
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[]>* d2;
+        typedef boost::detail::array_deleter<T2[]>* D2;
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<boost::detail::array_deleter<T2[]> >(s1);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct(p2);
         return boost::shared_ptr<T>(s1, p1);
     }
@@ -48,9 +48,9 @@ namespace boost {
         boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
         boost::detail::array_deleter<T2[]> d1(n1);
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[]>* d2;
+        typedef boost::detail::array_deleter<T2[]>* D2;
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<boost::detail::array_deleter<T2[]> >(s1);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct(p2, boost::detail::sp_forward<Args>(args)...);
         return boost::shared_ptr<T>(s1, p1);
     }
@@ -59,17 +59,17 @@ namespace boost {
     allocate_shared(const A& allocator, Args&&... args) {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
-        enum { 
-            N = boost::detail::array_total<T>::size 
+        enum {
+            N = boost::detail::array_total<T>::size
         };
         T1* p1 = 0;
         T2* p2 = 0;
         boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
         boost::detail::array_deleter<T2[N]> d1;
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[N]>* d2;
+        typedef boost::detail::array_deleter<T2[N]>* D2;
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<boost::detail::array_deleter<T2[N]> >(s1);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct(p2, boost::detail::sp_forward<Args>(args)...);
         return boost::shared_ptr<T>(s1, p1);
     }
@@ -77,7 +77,7 @@ namespace boost {
 #if !defined(BOOST_NO_CXX11_HDR_INITIALIZER_LIST)
     template<typename T, typename A>
     inline typename boost::detail::sp_if_array<T>::type
-    allocate_shared(const A& allocator, 
+    allocate_shared(const A& allocator,
         std::initializer_list<typename boost::detail::array_inner<T>::type> list) {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
@@ -89,10 +89,10 @@ namespace boost {
         boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
         boost::detail::array_deleter<T2[]> d1(n1);
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[]>* d2;
+        typedef boost::detail::array_deleter<T2[]>* D2;
         p3 = reinterpret_cast<T3*>(list.begin());
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<boost::detail::array_deleter<T2[]> >(s1);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct_list(p2, p3);
         return boost::shared_ptr<T>(s1, p1);
     }
@@ -104,8 +104,8 @@ namespace boost {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
         typedef const T2 T3;
-        enum { 
-            N = boost::detail::array_total<T>::size 
+        enum {
+            N = boost::detail::array_total<T>::size
         };
         T1* p1 = 0;
         T2* p2 = 0;
@@ -113,21 +113,21 @@ namespace boost {
         boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
         boost::detail::array_deleter<T2[N]> d1;
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[N]>* d2;
+        typedef boost::detail::array_deleter<T2[N]>* D2;
         p3 = reinterpret_cast<T3*>(list);
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<boost::detail::array_deleter<T2[N]> >(s1);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct_list(p2, p3);
         return boost::shared_ptr<T>(s1, p1);
     }
     template<typename T, typename A>
     inline typename boost::detail::sp_if_array<T>::type
-    allocate_shared(const A& allocator, std::size_t size, 
+    allocate_shared(const A& allocator, std::size_t size,
         const typename boost::detail::array_inner<T>::type& list) {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
         typedef const T2 T3;
-        enum { 
+        enum {
             M = boost::detail::array_total<T1>::size
         };
         T1* p1 = 0;
@@ -137,41 +137,41 @@ namespace boost {
         boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
         boost::detail::array_deleter<T2[]> d1(n1);
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[]>* d2;
+        typedef boost::detail::array_deleter<T2[]>* D2;
         p3 = reinterpret_cast<T3*>(list);
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<boost::detail::array_deleter<T2[]> >(s1);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct_list<M>(p2, p3);
         return boost::shared_ptr<T>(s1, p1);
     }
     template<typename T, typename A>
     inline typename boost::detail::sp_if_size_array<T>::type
-    allocate_shared(const A& allocator, 
+    allocate_shared(const A& allocator,
         const typename boost::detail::array_inner<T>::type& list) {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
         typedef const T2 T3;
-        enum { 
-            M = boost::detail::array_total<T1>::size, 
-            N = boost::detail::array_total<T>::size 
+        enum {
+            M = boost::detail::array_total<T1>::size,
+            N = boost::detail::array_total<T>::size
         };
         T1* p1 = 0;
         T2* p2 = 0;
-        T3* p3 = 0;        
+        T3* p3 = 0;
         boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
         boost::detail::array_deleter<T2[N]> d1;
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[N]>* d2;
+        typedef boost::detail::array_deleter<T2[N]>* D2;
         p3 = reinterpret_cast<T3*>(list);
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<boost::detail::array_deleter<T2[N]> >(s1);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct_list<M>(p2, p3);
         return boost::shared_ptr<T>(s1, p1);
     }
 #if defined(BOOST_HAS_RVALUE_REFS)
     template<typename T, typename A>
     inline typename boost::detail::sp_if_array<T>::type
-    allocate_shared(const A& allocator, std::size_t size, 
+    allocate_shared(const A& allocator, std::size_t size,
         typename boost::detail::array_base<T>::type&& value) {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
@@ -181,34 +181,70 @@ namespace boost {
         boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
         boost::detail::array_deleter<T2[]> d1(n1);
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[]>* d2;
+        typedef boost::detail::array_deleter<T2[]>* D2;
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<boost::detail::array_deleter<T2[]> >(s1);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct(p2, boost::detail::sp_forward<T2>(value));
         return boost::shared_ptr<T>(s1, p1);
     }
     template<typename T, typename A>
     inline typename boost::detail::sp_if_size_array<T>::type
-    allocate_shared(const A& allocator, 
+    allocate_shared(const A& allocator,
         typename boost::detail::array_base<T>::type&& value) {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
-        enum { 
-            N = boost::detail::array_total<T>::size 
+        enum {
+            N = boost::detail::array_total<T>::size
         };
         T1* p1 = 0;
         T2* p2 = 0;
         boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
         boost::detail::array_deleter<T2[N]> d1;
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[N]>* d2;
+        typedef boost::detail::array_deleter<T2[N]>* D2;
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<boost::detail::array_deleter<T2[N]> >(s1);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct(p2, boost::detail::sp_forward<T2>(value));
         return boost::shared_ptr<T>(s1, p1);
     }
 #endif
 #endif
+    template<typename T, typename A>
+    inline typename boost::detail::sp_if_array<T>::type
+    allocate_shared_noinit(const A& allocator, std::size_t size) {
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
+        T1* p1 = 0;
+        T2* p2 = 0;
+        std::size_t n1 = size * boost::detail::array_total<T1>::size;
+        boost::detail::allocate_array_helper<A, T2[]> a1(allocator, n1, &p2);
+        boost::detail::array_deleter<T2[]> d1(n1);
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        typedef boost::detail::array_deleter<T2[]>* D2;
+        p1 = reinterpret_cast<T1*>(p2);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
+        d2->construct_noinit(p2);
+        return boost::shared_ptr<T>(s1, p1);
+    }
+    template<typename T, typename A>
+    inline typename boost::detail::sp_if_size_array<T>::type
+    allocate_shared_noinit(const A& allocator) {
+        typedef typename boost::detail::array_inner<T>::type T1;
+        typedef typename boost::detail::array_base<T1>::type T2;
+        enum {
+            N = boost::detail::array_total<T>::size
+        };
+        T1* p1 = 0;
+        T2* p2 = 0;
+        boost::detail::allocate_array_helper<A, T2[N]> a1(allocator, &p2);
+        boost::detail::array_deleter<T2[N]> d1;
+        boost::shared_ptr<T> s1(p1, d1, a1);
+        typedef boost::detail::array_deleter<T2[N]>* D2;
+        p1 = reinterpret_cast<T1*>(p2);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
+        d2->construct_noinit(p2);
+        return boost::shared_ptr<T>(s1, p1);
+    }
 }
 
 #endif
diff --git a/include/boost/smart_ptr/detail/array_deleter.hpp b/include/boost/smart_ptr/detail/array_deleter.hpp
index 8ef0d11..7909265 100644
--- a/include/boost/smart_ptr/detail/array_deleter.hpp
+++ b/include/boost/smart_ptr/detail/array_deleter.hpp
@@ -34,13 +34,13 @@ namespace boost {
             }
 #if defined(BOOST_HAS_RVALUE_REFS)
             void construct(T* memory, T&& value) {
-                array_construct(memory, size, sp_forward<T>(value));
+                array_construct_value(memory, size, sp_forward<T>(value));
                 object = memory;                
             }
 #if defined(BOOST_HAS_VARIADIC_TMPL)
             template<typename... Args>
             void construct(T* memory, Args&&... args) {
-                array_construct(memory, size, sp_forward<Args>(args)...);
+                array_construct_args(memory, size, sp_forward<Args>(args)...);
                 object = memory;
             }
 #endif
@@ -85,13 +85,13 @@ namespace boost {
             }
 #if defined(BOOST_HAS_RVALUE_REFS)
             void construct(T* memory, T&& value) {
-                array_construct(memory, N, sp_forward<T>(value));
+                array_construct_value(memory, N, sp_forward<T>(value));
                 object = memory;                
             }
 #if defined(BOOST_HAS_VARIADIC_TMPL)
             template<typename... Args>
             void construct(T* memory, Args&&... args) {
-                array_construct(memory, N, sp_forward<Args>(args)...);
+                array_construct_args(memory, N, sp_forward<Args>(args)...);
                 object = memory;
             }
 #endif
diff --git a/include/boost/smart_ptr/detail/array_utility.hpp b/include/boost/smart_ptr/detail/array_utility.hpp
index b584599..3b685ad 100644
--- a/include/boost/smart_ptr/detail/array_utility.hpp
+++ b/include/boost/smart_ptr/detail/array_utility.hpp
@@ -55,7 +55,7 @@ namespace boost {
         }
 #if defined(BOOST_HAS_RVALUE_REFS)
         template<typename T>
-        inline void array_construct(T* memory, std::size_t size, T&& value) {
+        inline void array_construct_value(T* memory, std::size_t size, T&& value) {
             std::size_t i = 0;
             try {
                 for (; i < size; i++) {
@@ -69,7 +69,7 @@ namespace boost {
         }
 #if defined(BOOST_HAS_VARIADIC_TMPL)
         template<typename T, typename... Args>
-        inline void array_construct(T* memory, std::size_t size, Args&&... args) {
+        inline void array_construct_args(T* memory, std::size_t size, Args&&... args) {
             std::size_t i = 0;
             try {
                 for (; i < size; i++) {
diff --git a/include/boost/smart_ptr/make_shared_array.hpp b/include/boost/smart_ptr/make_shared_array.hpp
index cf63ecb..b9c197c 100644
--- a/include/boost/smart_ptr/make_shared_array.hpp
+++ b/include/boost/smart_ptr/make_shared_array.hpp
@@ -1,9 +1,9 @@
 /*
- * Copyright (c) 2012 Glen Joseph Fernandes 
+ * Copyright (c) 2012 Glen Joseph Fernandes
  * glenfe at live dot com
  *
- * Distributed under the Boost Software License, 
- * Version 1.0. (See accompanying file LICENSE_1_0.txt 
+ * Distributed under the Boost Software License,
+ * Version 1.0. (See accompanying file LICENSE_1_0.txt
  * or copy at http://boost.org/LICENSE_1_0.txt)
  */
 #ifndef BOOST_SMART_PTR_MAKE_SHARED_ARRAY_HPP
@@ -30,9 +30,9 @@ namespace boost {
         boost::detail::make_array_helper<T2[]> a1(n1, &p2);
         boost::detail::array_deleter<T2[]> d1(n1);
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[]>* d2;
-        p1 = reinterpret_cast<T1*>(p2);        
-        d2 = get_deleter<boost::detail::array_deleter<T2[]> >(s1);
+        typedef boost::detail::array_deleter<T2[]>* D2;
+        p1 = reinterpret_cast<T1*>(p2);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct(p2);
         return boost::shared_ptr<T>(s1, p1);
     }
@@ -48,9 +48,9 @@ namespace boost {
         boost::detail::make_array_helper<T2[]> a1(n1, &p2);
         boost::detail::array_deleter<T2[]> d1(n1);
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[]>* d2;
-        p1 = reinterpret_cast<T1*>(p2);        
-        d2 = get_deleter<boost::detail::array_deleter<T2[]> >(s1);
+        typedef boost::detail::array_deleter<T2[]>* D2;
+        p1 = reinterpret_cast<T1*>(p2);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct(p2, boost::detail::sp_forward<Args>(args)...);
         return boost::shared_ptr<T>(s1, p1);
     }
@@ -59,17 +59,17 @@ namespace boost {
     make_shared(Args&&... args) {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
-        enum { 
-            N = boost::detail::array_total<T>::size 
+        enum {
+            N = boost::detail::array_total<T>::size
         };
         T1* p1 = 0;
         T2* p2 = 0;
         boost::detail::make_array_helper<T2[N]> a1(&p2);
         boost::detail::array_deleter<T2[N]> d1;
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[N]>* d2;
-        p1 = reinterpret_cast<T1*>(p2);        
-        d2 = get_deleter<boost::detail::array_deleter<T2[N]> >(s1);
+        typedef boost::detail::array_deleter<T2[N]>* D2;
+        p1 = reinterpret_cast<T1*>(p2);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct(p2, boost::detail::sp_forward<Args>(args)...);
         return boost::shared_ptr<T>(s1, p1);
     }
@@ -88,13 +88,13 @@ namespace boost {
         boost::detail::make_array_helper<T2[]> a1(n1, &p2);
         boost::detail::array_deleter<T2[]> d1(n1);
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[]>* d2;        
+        typedef boost::detail::array_deleter<T2[]>* D2;
         p3 = reinterpret_cast<T3*>(list.begin());
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<boost::detail::array_deleter<T2[]> >(s1);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct_list(p2, p3);
         return boost::shared_ptr<T>(s1, p1);
-    }    
+    }
 #endif
 #if !defined(BOOST_NO_CXX11_UNIFIED_INITIALIZATION_SYNTAX)
     template<typename T>
@@ -103,8 +103,8 @@ namespace boost {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
         typedef const T2 T3;
-        enum { 
-            N = boost::detail::array_total<T>::size 
+        enum {
+            N = boost::detail::array_total<T>::size
         };
         T1* p1 = 0;
         T2* p2 = 0;
@@ -112,22 +112,22 @@ namespace boost {
         boost::detail::make_array_helper<T2[N]> a1(&p2);
         boost::detail::array_deleter<T2[N]> d1;
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[N]>* d2;        
+        typedef boost::detail::array_deleter<T2[N]>* D2;
         p3 = reinterpret_cast<T3*>(list);
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<boost::detail::array_deleter<T2[N]> >(s1);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct_list(p2, p3);
         return boost::shared_ptr<T>(s1, p1);
     }
     template<typename T>
     inline typename boost::detail::sp_if_array<T>::type
-    make_shared(std::size_t size, 
+    make_shared(std::size_t size,
         const typename boost::detail::array_inner<T>::type& list) {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
         typedef const T2 T3;
-        enum { 
-            M = boost::detail::array_total<T1>::size 
+        enum {
+            M = boost::detail::array_total<T1>::size
         };
         T1* p1 = 0;
         T2* p2 = 0;
@@ -136,10 +136,10 @@ namespace boost {
         boost::detail::make_array_helper<T2[]> a1(n1, &p2);
         boost::detail::array_deleter<T2[]> d1(n1);
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[]>* d2;        
+        typedef boost::detail::array_deleter<T2[]>* D2;
         p3 = reinterpret_cast<T3*>(list);
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<boost::detail::array_deleter<T2[]> >(s1);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct_list<M>(p2, p3);
         return boost::shared_ptr<T>(s1, p1);
     }
@@ -149,9 +149,9 @@ namespace boost {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
         typedef const T2 T3;
-        enum { 
+        enum {
             M = boost::detail::array_total<T1>::size,
-            N = boost::detail::array_total<T>::size 
+            N = boost::detail::array_total<T>::size
         };
         T1* p1 = 0;
         T2* p2 = 0;
@@ -159,17 +159,17 @@ namespace boost {
         boost::detail::make_array_helper<T2[N]> a1(&p2);
         boost::detail::array_deleter<T2[N]> d1;
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[N]>* d2;        
+        typedef boost::detail::array_deleter<T2[N]>* D2;
         p3 = reinterpret_cast<T3*>(list);
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<boost::detail::array_deleter<T2[N]> >(s1);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct_list<M>(p2, p3);
         return boost::shared_ptr<T>(s1, p1);
     }
 #if defined(BOOST_HAS_RVALUE_REFS)
     template<typename T>
     inline typename boost::detail::sp_if_array<T>::type
-    make_shared(std::size_t size, 
+    make_shared(std::size_t size,
         typename boost::detail::array_base<T>::type&& value) {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
@@ -179,9 +179,9 @@ namespace boost {
         boost::detail::make_array_helper<T2[]> a1(n1, &p2);
         boost::detail::array_deleter<T2[]> d1(n1);
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[]>* d2;
+        typedef boost::detail::array_deleter<T2[]>* D2;
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<boost::detail::array_deleter<T2[]> >(s1);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct(p2, boost::detail::sp_forward<T2>(value));
         return boost::shared_ptr<T>(s1, p1);
     }
@@ -190,17 +190,17 @@ namespace boost {
     make_shared(typename boost::detail::array_base<T>::type&& value) {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
-        enum { 
-            N = boost::detail::array_total<T>::size 
+        enum {
+            N = boost::detail::array_total<T>::size
         };
         T1* p1 = 0;
         T2* p2 = 0;
         boost::detail::make_array_helper<T2[N]> a1(&p2);
         boost::detail::array_deleter<T2[N]> d1;
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[N]>* d2;
+        typedef boost::detail::array_deleter<T2[N]>* D2;
         p1 = reinterpret_cast<T1*>(p2);
-        d2 = get_deleter<boost::detail::array_deleter<T2[N]> >(s1);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct(p2, boost::detail::sp_forward<T2>(value));
         return boost::shared_ptr<T>(s1, p1);
     }
@@ -217,9 +217,9 @@ namespace boost {
         boost::detail::make_array_helper<T2[]> a1(n1, &p2);
         boost::detail::array_deleter<T2[]> d1(n1);
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[]>* d2;
-        p1 = reinterpret_cast<T1*>(p2);        
-        d2 = get_deleter<boost::detail::array_deleter<T2[]> >(s1);
+        typedef boost::detail::array_deleter<T2[]>* D2;
+        p1 = reinterpret_cast<T1*>(p2);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct_noinit(p2);
         return boost::shared_ptr<T>(s1, p1);
     }
@@ -228,17 +228,17 @@ namespace boost {
     make_shared_noinit() {
         typedef typename boost::detail::array_inner<T>::type T1;
         typedef typename boost::detail::array_base<T1>::type T2;
-        enum { 
-            N = boost::detail::array_total<T>::size 
+        enum {
+            N = boost::detail::array_total<T>::size
         };
         T1* p1 = 0;
         T2* p2 = 0;
         boost::detail::make_array_helper<T2[N]> a1(&p2);
         boost::detail::array_deleter<T2[N]> d1;
         boost::shared_ptr<T> s1(p1, d1, a1);
-        boost::detail::array_deleter<T2[N]>* d2;
-        p1 = reinterpret_cast<T1*>(p2);     
-        d2 = get_deleter<boost::detail::array_deleter<T2[N]> >(s1);
+        typedef boost::detail::array_deleter<T2[N]>* D2;
+        p1 = reinterpret_cast<T1*>(p2);
+        D2 d2 = static_cast<D2>(s1._internal_get_untyped_deleter());
         d2->construct_noinit(p2);
         return boost::shared_ptr<T>(s1, p1);
     }
diff --git a/make_shared_array.html b/make_shared_array.html
index c1db41f..1f0f4d3 100644
--- a/make_shared_array.html
+++ b/make_shared_array.html
@@ -96,6 +96,12 @@
 
     template&lt;typename T&gt;
     shared_ptr&lt;T[N]&gt; <a href="#functions">make_shared_noinit</a>();
+    
+    template&lt;typename T, typename A&gt;
+    shared_ptr&lt;T[]&gt; <a href="#functions">allocate_shared_noinit</a>(const A&amp; allocator, size_t size);
+
+    template&lt;typename T, typename A&gt;
+    shared_ptr&lt;T[N]&gt; <a href="#functions">allocate_shared_noinit</a>(const A&amp; allocator);
 }</pre>
     <h2><a name="functions">Free Functions</a></h2>
     <pre>template&lt;typename T, typename... Args&gt;
@@ -197,15 +203,19 @@ template&lt;typename T, typename A&gt;
         fixed size array.</p>
     </blockquote>
     <pre>template&lt;typename T&gt;
-    shared_ptr&lt;T[]&gt; make_shared_noinit(size_t size);</pre>
+    shared_ptr&lt;T[]&gt; make_shared_noinit(size_t size);
+template&lt;typename T, typename A&gt;
+    shared_ptr&lt;T[]&gt; allocate_shared_noinit(const A&amp; allocator, size_t size);</pre>
     <blockquote>
-      <p><b>Description:</b> This overload does not perform value 
+      <p><b>Description:</b> These overloads do not perform any value 
         initialization of elements.</p>
     </blockquote>
     <pre>template&lt;typename T&gt;
-    shared_ptr&lt;T[N]&gt; make_shared_noinit();</pre>
+    shared_ptr&lt;T[N]&gt; make_shared_noinit();
+template&lt;typename T, typename A&gt;
+    shared_ptr&lt;T[N]&gt; allocate_shared_noinit(const A&amp; allocator);</pre>
     <blockquote>
-      <p><b>Description:</b> This overload of the utility above is used for a 
+      <p><b>Description:</b> These overloads of the utilities above are for a 
         fixed size array.</p>
     </blockquote>
     <h2><a name="example">Example</a></h2>
diff --git a/test/allocate_shared_array_esft_test.cpp b/test/allocate_shared_array_esft_test.cpp
index 2315421..cea73c6 100644
--- a/test/allocate_shared_array_esft_test.cpp
+++ b/test/allocate_shared_array_esft_test.cpp
@@ -38,5 +38,15 @@ int main() {
             BOOST_TEST(type::instances == 3);
         }
     }
+    BOOST_TEST(type::instances == 0);
+    {
+        boost::shared_ptr<type[]> a1 = boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 3);
+        try {
+            a1[0].shared_from_this();
+            BOOST_ERROR("shared_from_this did not throw");
+        } catch (...) {
+            BOOST_TEST(type::instances == 3);
+        }
+    }
     return boost::report_errors();
 }
diff --git a/test/allocate_shared_array_test.cpp b/test/allocate_shared_array_test.cpp
index 91f3fb5..84ef3a8 100644
--- a/test/allocate_shared_array_test.cpp
+++ b/test/allocate_shared_array_test.cpp
@@ -121,5 +121,79 @@ int main() {
         BOOST_TEST(type::instances == 0);
     }
 #endif
+    {
+        boost::shared_ptr<int[]> a1 = boost::allocate_shared_noinit<int[]>(std::allocator<int>(), 3);
+        int* a2 = a1.get();
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(a2 != 0);
+        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);       
+    }
+    {
+        boost::shared_ptr<int[3]> a1 = boost::allocate_shared_noinit<int[3]>(std::allocator<int>());
+        int* a2 = a1.get();
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(a2 != 0);
+        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);       
+    }
+    {
+        boost::shared_ptr<const int[]> a1 = boost::allocate_shared_noinit<const int[]>(std::allocator<int>(), 3);
+        const int* a2 = a1.get();
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(a2 != 0);
+        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+    }
+    {
+        boost::shared_ptr<const int[3]> a1 = boost::allocate_shared_noinit<const int[3]>(std::allocator<int>());
+        const int* a2 = a1.get();
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(a2 != 0);
+        BOOST_TEST(size_t(a2) % boost::alignment_of<int>::value == 0);
+    }
+    BOOST_TEST(type::instances == 0);
+    {
+        boost::shared_ptr<type[]> a1 = boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 3);
+        type* a2 = a1.get();
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(a2 != 0);
+        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        BOOST_TEST(type::instances == 3);
+        boost::weak_ptr<type[]> w1 = a1;
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+    BOOST_TEST(type::instances == 0);
+    {
+        boost::shared_ptr<type[3]> a1 = boost::allocate_shared_noinit<type[3]>(std::allocator<type>());
+        type* a2 = a1.get();
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(a2 != 0);
+        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        BOOST_TEST(type::instances == 3);
+        boost::weak_ptr<type[3]> w1 = a1;
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+    BOOST_TEST(type::instances == 0);
+    {
+        boost::shared_ptr<const type[]> a1 = boost::allocate_shared_noinit<const type[]>(std::allocator<type>(), 3);
+        const type* a2 = a1.get();
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(a2 != 0);
+        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        BOOST_TEST(type::instances == 3);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+    BOOST_TEST(type::instances == 0);
+    {
+        boost::shared_ptr<const type[3]> a1 = boost::allocate_shared_noinit<const type[3]>(std::allocator<type>());
+        const type* a2 = a1.get();
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(a2 != 0);
+        BOOST_TEST(size_t(a2) % boost::alignment_of<type>::value == 0);
+        BOOST_TEST(type::instances == 3);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
     return boost::report_errors();
 }
diff --git a/test/allocate_shared_array_throws_test.cpp b/test/allocate_shared_array_throws_test.cpp
index 65a7985..d300f2c 100644
--- a/test/allocate_shared_array_throws_test.cpp
+++ b/test/allocate_shared_array_throws_test.cpp
@@ -59,5 +59,19 @@ int main() {
         BOOST_TEST(type::instances == 0);
     }
 #endif
+    BOOST_TEST(type::instances == 0);
+    try {
+        boost::allocate_shared_noinit<type[]>(std::allocator<type>(), 6);
+        BOOST_ERROR("allocate_shared_noinit did not throw");
+    } catch (...) {
+        BOOST_TEST(type::instances == 0);
+    }
+    BOOST_TEST(type::instances == 0);
+    try {
+        boost::allocate_shared_noinit<type[][2]>(std::allocator<type>(), 3);
+        BOOST_ERROR("allocate_shared_noinit did not throw");
+    } catch (...) {
+        BOOST_TEST(type::instances == 0);
+    }
     return boost::report_errors();
 }
diff --git a/test/allocate_shared_arrays_test.cpp b/test/allocate_shared_arrays_test.cpp
index ab22c23..7c719ce 100644
--- a/test/allocate_shared_arrays_test.cpp
+++ b/test/allocate_shared_arrays_test.cpp
@@ -100,5 +100,61 @@ int main() {
         BOOST_TEST(type::instances == 0);
     }
 #endif
+    {
+        boost::shared_ptr<int[][2][2]> a1 = boost::allocate_shared_noinit<int[][2][2]>(std::allocator<int>(), 2);
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+    }
+    {
+        boost::shared_ptr<int[2][2][2]> a1 = boost::allocate_shared_noinit<int[2][2][2]>(std::allocator<int>());
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+    }    
+    {
+        boost::shared_ptr<const int[][2][2]> a1 = boost::allocate_shared_noinit<const int[][2][2]>(std::allocator<int>(), 2);
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+    }
+    {
+        boost::shared_ptr<const int[2][2][2]> a1 = boost::allocate_shared_noinit<const int[2][2][2]>(std::allocator<int>());
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+    }    
+    BOOST_TEST(type::instances == 0);
+    {
+        boost::shared_ptr<type[][2][2]> a1 = boost::allocate_shared_noinit<type[][2][2]>(std::allocator<type>(), 2);
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(type::instances == 8);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+    BOOST_TEST(type::instances == 0);
+    {
+        boost::shared_ptr<type[2][2][2]> a1 = boost::allocate_shared_noinit<type[2][2][2]>(std::allocator<type>());
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(type::instances == 8);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+    BOOST_TEST(type::instances == 0);
+    {
+        boost::shared_ptr<const type[][2][2]> a1 = boost::allocate_shared_noinit<const type[][2][2]>(std::allocator<type>(), 2);
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(type::instances == 8);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
+    BOOST_TEST(type::instances == 0);
+    {
+        boost::shared_ptr<const type[2][2][2]> a1 = boost::allocate_shared_noinit<const type[2][2][2]>(std::allocator<type>());
+        BOOST_TEST(a1.get() != 0);
+        BOOST_TEST(a1.use_count() == 1);
+        BOOST_TEST(type::instances == 8);
+        a1.reset();
+        BOOST_TEST(type::instances == 0);
+    }
     return boost::report_errors();
 }