diff --git a/include/boost/smart_ptr/detail/array_allocator.hpp b/include/boost/smart_ptr/detail/array_allocator.hpp
index 3371545..bac8984 100644
--- a/include/boost/smart_ptr/detail/array_allocator.hpp
+++ b/include/boost/smart_ptr/detail/array_allocator.hpp
@@ -10,6 +10,7 @@
 #define BOOST_SMART_PTR_DETAIL_ARRAY_ALLOCATOR_HPP
 
 #include <boost/smart_ptr/detail/array_traits.hpp>
+#include <boost/smart_ptr/detail/as_pair.hpp>
 #include <boost/type_traits/alignment_of.hpp>
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
 #include <memory>
@@ -46,19 +47,18 @@ namespace boost {
 
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
             typedef typename std::allocator_traits<A>::
-                template rebind_alloc<Y>::other YA;
-
+                template rebind_alloc<Y> YA;
             typedef typename std::allocator_traits<A>::
-                template rebind_alloc<char>::other CA;
-
+                template rebind_alloc<char> CA;
             typedef typename std::allocator_traits<A>::
-                template rebind_traits<Y>::other YT;
-
+                template rebind_traits<Y> YT;
             typedef typename std::allocator_traits<A>::
-                template rebind_traits<char>::other CT;
+                template rebind_traits<char> CT;
 #else
-            typedef typename A::template rebind<Y>::other YA;
-            typedef typename A::template rebind<char>::other CA;
+            typedef typename A::
+                template rebind<Y>::other YA;
+            typedef typename A::
+                template rebind<char>::other CA;
 #endif
 
         public:
@@ -87,40 +87,37 @@ namespace boost {
                 typedef as_allocator<T, A, U> other;
             };
 
-            as_allocator(const A& allocator_, type** data_)
-                : allocator(allocator_),
-                  data(data_) {
+            as_allocator(const A& allocator, type** data)
+                : pair(allocator, data) {
             }
 
-            as_allocator(const A& allocator_, std::size_t size_, type** data_)
+            as_allocator(const A& allocator, std::size_t size_, type** data)
                 : ms_allocator_base<T>(size_),
-                  allocator(allocator_),
-                  data(data_) {
+                  pair(allocator, data) {
             }
 
             template<class U>
             as_allocator(const as_allocator<T, A, U>& other) 
                 : ms_allocator_base<T>(other),
-                  allocator(other.allocator),
-                  data(other.data) {
+                  pair(other.pair, other.pair.data) {
             }
 
             pointer address(reference value) const {
-                return allocator.address(value);
+                return pair.address(value);
             }
 
             const_pointer address(const_reference value) const {
-                return allocator.address(value);
+                return pair.address(value);
             }
 
             size_type max_size() const {
-                return allocator.max_size();
+                return pair.max_size();
             }
 
             pointer allocate(size_type count, const void* value = 0) {
                 std::size_t a1 = boost::alignment_of<type>::value;
                 std::size_t n1 = count * sizeof(Y) + a1 - 1;
-                CA ca(allocator);
+                CA ca(pair);
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
                 char* p1 = CT::allocate(ca, size + n1, value);
 #else
@@ -130,7 +127,7 @@ namespace boost {
                 while (std::size_t(p2) % a1 != 0) {
                     p2--;
                 }
-                *data = reinterpret_cast<type*>(p2);
+                *pair.data = reinterpret_cast<type*>(p2);
                 return reinterpret_cast<Y*>(p1);
             }
 
@@ -138,7 +135,7 @@ namespace boost {
                 std::size_t a1 = boost::alignment_of<type>::value;
                 std::size_t n1 = count * sizeof(Y) + a1 - 1;
                 char* p1 = reinterpret_cast<char*>(memory);
-                CA ca(allocator);
+                CA ca(pair);
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
                 CT::deallocate(ca, p1, size + n1);
 #else
@@ -148,23 +145,23 @@ namespace boost {
 
             void construct(pointer memory, const Y& value) {
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                YT::construct(allocator, memory, value);
+                YT::construct(pair, memory, value);
 #else
-                allocator.construct(memory, value);
+                pair.construct(memory, value);
 #endif
             }
 
             void destroy(pointer memory) {
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                YT::destroy(allocator, memory);
+                YT::destroy(pair, memory);
 #else
-                allocator.destroy(memory);
+                pair.destroy(memory);
 #endif
             }
 
             template<typename U>
             bool operator==(const as_allocator<T, A, U>& other) const {
-                return allocator == other.allocator;
+                return pair == other.pair;
             }
 
             template<typename U>
@@ -173,8 +170,7 @@ namespace boost {
             }
 
         private:
-            YA allocator;
-            type** data;
+            as_pair<YA, type**> pair;
         };
 
         template<typename T, typename Y = char>
diff --git a/include/boost/smart_ptr/detail/array_deleter.hpp b/include/boost/smart_ptr/detail/array_deleter.hpp
index 7d99795..b4ed44f 100644
--- a/include/boost/smart_ptr/detail/array_deleter.hpp
+++ b/include/boost/smart_ptr/detail/array_deleter.hpp
@@ -11,6 +11,7 @@
 
 #include <boost/config.hpp>
 #include <boost/smart_ptr/detail/array_traits.hpp>
+#include <boost/smart_ptr/detail/as_pair.hpp>
 #include <boost/type_traits/has_trivial_constructor.hpp>
 #include <boost/type_traits/has_trivial_destructor.hpp>
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
@@ -46,54 +47,42 @@ namespace boost {
         public:
             typedef typename array_inner<T>::type type;
 
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-            as_deleter(const A& allocator_) 
-                : allocator(allocator_),
-                  object(0) {
+            as_deleter(const A& allocator) 
+                : pair(allocator, 0) {
             }
-#else
-            as_deleter(const A&)
-                : object(0) {
-            }
-#endif
 
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-            as_deleter(const A& allocator_, std::size_t size_)
+            as_deleter(const A& allocator, std::size_t size_)
                 : ms_deleter_base<T>(size_),
-                  allocator(allocator_),
-                  object(0) {
+                  pair(allocator, 0) {
             }
-#else
-            as_deleter(const A&, std::size_t size_)
-                : ms_deleter_base<T>(size_),
-                  object(0) {
-            }
-#endif
 
             void init(type* memory) {
                 value_init(memory);
-                object = memory;
+                pair.data = memory;
             }
 
             template<std::size_t N>
             void init(type* memory, const type* value) {
                 value_init<N>(memory, value);
-                object = memory;
+                pair.data = memory;
             }
 
             void operator()(const void*) {
-                if (object) {
-                    destroy(object, size);
+                if (pair.data) {
+                    destroy(pair.data, size);
                 }
             }
 
         private:
+
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
             typedef typename std::allocator_traits<A>::
-                template rebind_alloc<type>::other TA;
-
+                template rebind_alloc<type> TA;
             typedef typename std::allocator_traits<A>::
-                template rebind_traits<type>::other TT;
+                template rebind_traits<type> TT;
+#else
+            typedef typename A::
+                template rebind<type>::other TA;
 #endif
 
             void destroy(type*, std::size_t, boost::true_type) {
@@ -102,7 +91,7 @@ namespace boost {
             void destroy(type* memory, std::size_t n, boost::false_type) {
                 for (std::size_t i = n; i > 0;) {
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                    TT::destroy(allocator, &memory[--i]);
+                    TT::destroy(pair, &memory[--i]);
 #else
                     memory[--i].~type();
 #endif
@@ -117,7 +106,7 @@ namespace boost {
             void value_init(type* memory, boost::true_type) {
                 for (std::size_t i = 0; i < size; i++) {
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                    TT::construct(allocator, memory + i);
+                    TT::construct(pair, memory + i);
 #else
                     void* p1 = memory + i;
                     ::new(p1) type();
@@ -131,7 +120,7 @@ namespace boost {
                 try {
                     for (; i < size; i++) {
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                        TT::construct(allocator, memory + i);
+                        TT::construct(pair, memory + i);
 #else
                         void* p1 = memory + i;
                         ::new(p1) type();
@@ -144,7 +133,7 @@ namespace boost {
 #else
                 for (std::size_t i = 0; i < size; i++) {
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                    TT::construct(allocator, memory + i);
+                    TT::construct(pair, memory + i);
 #else
                     void* p1 = memory + i;
                     ::new(p1) type();
@@ -165,7 +154,7 @@ namespace boost {
                 try {
                     for (; i < size; i++) {
 #if !defined(BOOST_NO_CXX11_ALLOCATOR)
-                        TT::construct(allocator, memory + i, list[i % N]);
+                        TT::construct(pair, memory + i, list[i % N]);
 #else
                         void* p1 = memory + i;
                         ::new(p1) type(list[i % N]);
@@ -187,10 +176,7 @@ namespace boost {
 #endif
             }
 
-#if !defined(BOOST_NO_CXX11_ALLOCATOR)
-            TA allocator;
-#endif
-            type* object;
+            as_pair<TA, type*> pair;
         };
 
         template<typename T>
diff --git a/include/boost/smart_ptr/detail/as_pair.hpp b/include/boost/smart_ptr/detail/as_pair.hpp
new file mode 100644
index 0000000..829adc0
--- /dev/null
+++ b/include/boost/smart_ptr/detail/as_pair.hpp
@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2014 Glen Joseph Fernandes 
+ * glenfe at live dot com
+ *
+ * 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_DETAIL_AS_PAIR_HPP
+#define BOOST_SMART_PTR_DETAIL_AS_PAIR_HPP
+
+#include <cstddef>
+
+namespace boost {
+    namespace detail {
+        template<typename A, typename T>
+        struct as_pair
+            : A {
+            as_pair(const A& allocator, const T& value)
+                : A(allocator),
+                  data(value) {
+            }
+
+            T data;
+        };
+    }
+}
+
+#endif