Support GCC's -Wconversion -Wfloat-conversion -Warith-conversion -Wsign-conversion warnings.

bench/bench_adaptive_node_pool.cpp

@@ -194,17 +194,17 @@ void list_test_template(std::size_t num_iterations, std::size_t num_elements, bo
                   << ";"
                   << num_elements
                   << ";"
-                  << float(tinsert)/(num_iterations*num_elements)
+                  << float(tinsert)/float(num_iterations*num_elements)
                   << ";"
                   << (unsigned int)insert_stats.system_bytes
                   << ";"
-                  << float(insert_stats.system_bytes)/(num_iterations*num_elements*sizeof_node)*100.0-100.0
+                  << float(insert_stats.system_bytes)/float(num_iterations*num_elements*sizeof_node)*100.0-100.0
                   << ";"
                   << (unsigned int)insert_inuse
                   << ";"
-                  << (float(insert_inuse)/(num_iterations*num_elements*sizeof_node)*100.0)-100.0
+                  << (float(insert_inuse)/float(num_iterations*num_elements*sizeof_node)*100.0)-100.0
                   << ";";
-   std::cout   << float(terase)/(num_iterations*num_elements)
+   std::cout   << float(terase)/float(num_iterations*num_elements)
                << ";"
                << (unsigned int)erase_stats.system_bytes
                << ";"
@@ -215,11 +215,11 @@ void list_test_template(std::size_t num_iterations, std::size_t num_elements, bo
       std::cout << std::endl
                << "Allocator: " << get_allocator_name<Allocator>::get()
                << std::endl
-               << "  allocation/deallocation(ns): " << float(tinsert)/(num_iterations*num_elements) <<  '\t' << float(terase)/(num_iterations*num_elements)
+               << "  allocation/deallocation(ns): " << float(tinsert)/float(num_iterations*num_elements) <<  '\t' << float(terase)/float(num_iterations*num_elements)
                << std::endl
-               << "  Sys MB(overh.)/Inuse MB(overh.): " << (float)insert_stats.system_bytes/(1024*1024) << "(" << float(insert_stats.system_bytes)/(num_iterations*num_elements*sizeof_node)*100.0-100.0 << "%)"
+               << "  Sys MB(overh.)/Inuse MB(overh.): " << (float)insert_stats.system_bytes/(1024*1024) << "(" << float(insert_stats.system_bytes)/float(num_iterations*num_elements*sizeof_node)*100.0-100.0 << "%)"
                << " / "
-               << (float)insert_inuse/(1024*1024) << "(" << (float(insert_inuse)/(num_iterations*num_elements*sizeof_node)*100.0)-100.0 << "%)"
+               << (float)insert_inuse/(1024*1024) << "(" << (float(insert_inuse)/float(num_iterations*num_elements*sizeof_node)*100.0)-100.0 << "%)"
                << std::endl
                << "  system MB/inuse bytes after:    " << (float)erase_stats.system_bytes/(1024*1024) << '\t' << bc::dlmalloc_in_use_memory()
                << std::endl  << std::endl;

bench/bench_alloc.cpp

@@ -120,12 +120,12 @@ void allocation_timing_test(unsigned int num_iterations, unsigned int num_elemen
       std::cout   << "  Malloc type:               " << malloc_name
                   << std::endl
                   << "  allocation ns:             "
-                  << float(nseconds)/(num_iterations*num_elements)
+                  << float(nseconds)/float(num_iterations*num_elements)
                   << std::endl
                   << "  capacity  -  alloc calls (new/expand):  "
                      << (unsigned int)capacity << "  -  "
-                     << (float(numalloc) + float(numexpand))/num_iterations
+                     << (float(numalloc) + float(numexpand))/float(num_iterations)
-                     << "(" << float(numalloc)/num_iterations << "/" << float(numexpand)/num_iterations << ")"
+                     << "(" << float(numalloc)/float(num_iterations) << "/" << float(numexpand)/float(num_iterations) << ")"
                   << std::endl << std::endl;
       dlmalloc_trim(0);
    }

bench/bench_alloc_expand_bwd.cpp

@@ -147,13 +147,13 @@ void vector_test_template(unsigned int num_iterations, unsigned int num_elements
                   << ";"
                   << capacity
                   << ";"
-                  << float(nseconds)/(num_iterations*num_elements)
+                  << float(nseconds)/float(num_iterations*num_elements)
                   << ";"
-                  << (float(numalloc) + float(numexpand))/num_iterations
+                  << (float(numalloc) + float(numexpand))/float(num_iterations)
                   << ";"
-                  << float(numalloc)/num_iterations
+                  << float(numalloc)/float(num_iterations)
                   << ";"
-                  << float(numexpand)/num_iterations
+                  << float(numexpand)/float(num_iterations)
                   << std::endl;
    }
    else{
@@ -161,12 +161,12 @@ void vector_test_template(unsigned int num_iterations, unsigned int num_elements
                   << "Allocator: " << get_allocator_name<Allocator>::get()
                   << std::endl
                   << "  push_back ns:              "
-                  << float(nseconds)/(num_iterations*num_elements)
+                  << float(nseconds)/float(num_iterations*num_elements)
                   << std::endl
                   << "  capacity  -  alloc calls (new/expand):  "
                      << (unsigned int)capacity << "  -  "
-                     << (float(numalloc) + float(numexpand))/num_iterations
+                     << (float(numalloc) + float(numexpand))/float(num_iterations)
-                     << "(" << float(numalloc)/num_iterations << "/" << float(numexpand)/num_iterations << ")"
+                     << "(" << float(numalloc)/float(num_iterations) << "/" << float(numexpand)/float(num_iterations) << ")"
                   << std::endl;
       std::cout   << '\n'
                   << "    -----------------------------------    "

bench/bench_alloc_expand_fwd.cpp

@@ -151,12 +151,12 @@ void vector_test_template(unsigned int num_iterations, unsigned int num_elements
                << "Allocator: " << typeid(typename Container::allocator_type).name()
                << std::endl
                << "  push_back ns:              "
-               << float(nseconds)/(num_iterations*num_elements)
+               << float(nseconds)/float(num_iterations*num_elements)
                << std::endl
                << "  capacity  -  alloc calls (new/expand):  "
                   << (unsigned int)capacity << "  -  "
-                  << (float(numalloc) + float(numexpand))/num_iterations
+                  << (float(numalloc) + float(numexpand))/float(num_iterations)
-                  << "(" << float(numalloc)/num_iterations << "/" << float(numexpand)/num_iterations << ")"
+                  << "(" << float(numalloc)/float(num_iterations) << "/" << float(numexpand)/float(num_iterations) << ")"
                << std::endl << std::endl;
    bc::dlmalloc_trim(0);
 }

bench/bench_alloc_shrink_to_fit.cpp

@@ -114,7 +114,7 @@ void vector_test_template(unsigned int num_iterations, unsigned int num_elements
                   << ";"
                   << num_shrink
                   << ";"
-                  << float(nseconds)/(num_iterations*num_elements)
+                  << float(nseconds)/float(num_iterations*num_elements)
                   << std::endl;
    }
    else{
@@ -124,7 +124,7 @@ void vector_test_template(unsigned int num_iterations, unsigned int num_elements
                   << "  num_shrink:         " << num_shrink
                   << std::endl
                   << "  shrink_to_fit ns:   "
-                  << float(nseconds)/(num_iterations*num_elements)
+                  << float(nseconds)/float(num_iterations*num_elements)
                   << std::endl << std::endl;
    }
    bc::dlmalloc_trim(0);

bench/bench_alloc_stable_vector_burst.cpp

@@ -123,7 +123,7 @@ void stable_vector_test_template(unsigned int num_iterations, unsigned int num_e
                         << ";"
                         << num_elements
                         << ";"
-                        << float(nseconds)/(num_iterations*num_elements)
+                        << float(nseconds)/float(num_iterations*num_elements)
                         << ";";
          }
          else{
@@ -132,7 +132,7 @@ void stable_vector_test_template(unsigned int num_iterations, unsigned int num_e
                         << GetContainer<Allocator>::vector_name()
                         << std::endl
                         << "  allocation ns:   "
-                        << float(nseconds)/(num_iterations*num_elements);
+                        << float(nseconds)/float(num_iterations*num_elements);
          }
 //         top_capacity = l.capacity();
          //Now preprocess ranges to erase
@@ -160,13 +160,13 @@ void stable_vector_test_template(unsigned int num_iterations, unsigned int num_e
    }
 
    if(csv_output){
-      std::cout      << float(nseconds)/(num_iterations*num_elements)
+      std::cout      << float(nseconds)/float(num_iterations*num_elements)
                      << std::endl;
    }
    else{
       std::cout      << '\t'
                      << "  deallocation ns: "
-                     << float(nseconds)/(num_iterations*num_elements)/*
+                     << float(nseconds)/float(num_iterations*num_elements)/*
                      << std::endl
                      << "  max capacity:    "
                      << static_cast<unsigned int>(top_capacity)

bench/bench_vectors.cpp

@@ -241,7 +241,7 @@ void vector_test_template(std::size_t num_iterations, std::size_t num_elements,
    nanosecond_type nseconds = timer.elapsed().wall;
 
    std::cout   << cont_name << "->" << op.name() <<" ns: "
-               << float(nseconds)/(num_iterations*num_elements)
+               << float(nseconds)/float(num_iterations*num_elements)
                << '\t'
                << "Capacity: " << capacity
                << "\n";

bench/detail/varray.hpp

@@ -1617,7 +1617,7 @@ private:
     //   Linear O(N).
     void swap_dispatch_impl(iterator first_sm, iterator last_sm, iterator first_la, iterator last_la, true_type const& /*use_memop*/)
     {
-        //BOOST_ASSERT_MSG(boost::container::iterator_distance(first_sm, last_sm) <= boost::container::iterator_distance(first_la, last_la));
+        //BOOST_ASSERT_MSG(boost::container::iterator_udistance(first_sm, last_sm) <= boost::container::iterator_udistance(first_la, last_la));
 
         namespace sv = varray_detail;
         for (; first_sm != last_sm ; ++first_sm, ++first_la)
@@ -1632,7 +1632,7 @@ private:
             ::memcpy((addressof)(*first_la), temp_ptr, sizeof(value_type));
         }
 
-        ::memcpy(first_sm, first_la, sizeof(value_type) * boost::container::iterator_distance(first_la, last_la));
+        ::memcpy(first_sm, first_la, sizeof(value_type) * boost::container::iterator_udistance(first_la, last_la));
     }
 
     // @par Throws
@@ -1641,7 +1641,7 @@ private:
     //   Linear O(N).
     void swap_dispatch_impl(iterator first_sm, iterator last_sm, iterator first_la, iterator last_la, false_type const& /*use_memop*/)
     {
-        //BOOST_ASSERT_MSG(boost::container::iterator_distance(first_sm, last_sm) <= boost::container::iterator_distance(first_la, last_la));
+        //BOOST_ASSERT_MSG(boost::container::iterator_udistance(first_sm, last_sm) <= boost::container::iterator_udistance(first_la, last_la));
 
         namespace sv = varray_detail;
         for (; first_sm != last_sm ; ++first_sm, ++first_la)
@@ -1704,7 +1704,7 @@ private:
     {
         errh::check_iterator_end_eq(*this, position);
 
-        size_type count = boost::container::iterator_distance(first, last);
+        size_type count = boost::container::iterator_udistance(first, last);
 
         errh::check_capacity(*this, m_size + count);                                             // may throw
 
@@ -1736,16 +1736,16 @@ private:
         {
             namespace sv = varray_detail;
 
-            std::ptrdiff_t d = boost::container::iterator_distance(position, this->begin() + Capacity);
+            std::size_t d = boost::container::iterator_udistance(position, this->begin() + Capacity);
             std::size_t count = sv::uninitialized_copy_s(first, last, position, d);                     // may throw
 
-            errh::check_capacity(*this, count <= static_cast<std::size_t>(d) ? m_size + count : Capacity + 1);  // may throw
+            errh::check_capacity(*this, count <= d ? m_size + count : Capacity + 1);  // may throw
 
             m_size += count;
         }
         else
         {
-            size_type count = boost::container::iterator_distance(first, last);
+            size_type count = boost::container::iterator_udistance(first, last);
 
             errh::check_capacity(*this, m_size + count);                                                // may throw
 
@@ -1799,7 +1799,7 @@ private:
     {
         namespace sv = varray_detail;
 
-        size_type s = boost::container::iterator_distance(first, last);
+        size_type s = boost::container::iterator_udistance(first, last);
 
         errh::check_capacity(*this, s);                                     // may throw
 
@@ -1835,11 +1835,11 @@ private:
 
         sv::destroy(it, this->end());
 
-        std::ptrdiff_t d = boost::container::iterator_distance(it, this->begin() + Capacity);
+        std::size_t d = boost::container::iterator_udistance(it, this->begin() + Capacity);
         std::size_t count = sv::uninitialized_copy_s(first, last, it, d);                                   // may throw
         s += count;
 
-        errh::check_capacity(*this, count <= static_cast<std::size_t>(d) ? s : Capacity + 1);               // may throw
+        errh::check_capacity(*this, count <= d ? s : Capacity + 1);               // may throw
 
         m_size = s; // update end
     }

bench/detail/varray_util.hpp

@@ -175,7 +175,7 @@ template <typename I, typename O>
 inline O copy_dispatch(I first, I last, O dst, bcd::true_type const& /*use_memmove*/)
 {
    typedef typename ::boost::container::iterator_traits<I>::value_type value_type;
-   const std::size_t d = boost::container::iterator_distance(first, last);
+   const std::size_t d = boost::container::iterator_udistance(first, last);
    ::memmove(boost::container::dtl::addressof(*dst), boost::container::dtl::addressof(*first), sizeof(value_type) * d);
    return dst + d;
 }
@@ -205,7 +205,7 @@ O uninitialized_copy_dispatch(I first, I last, O dst,
                               bcd::true_type const& /*use_memcpy*/)
 {
    typedef typename ::boost::container::iterator_traits<I>::value_type value_type;
-   const std::size_t d = boost::container::iterator_distance(first, last);
+   const std::size_t d = boost::container::iterator_udistance(first, last);
    ::memcpy(boost::container::dtl::addressof(*dst), boost::container::dtl::addressof(*first), sizeof(value_type) * d);
    return dst + d;
 }
@@ -237,7 +237,7 @@ O uninitialized_move_dispatch(I first, I last, O dst,
                               bcd::true_type const& /*use_memcpy*/)
 {
    typedef typename ::boost::container::iterator_traits<I>::value_type value_type;
-   const std::size_t d = boost::container::iterator_distance(first, last);
+   const std::size_t d = boost::container::iterator_udistance(first, last);
    ::memcpy(boost::container::dtl::addressof(*dst), boost::container::dtl::addressof(*first), sizeof(value_type) * d);
    return dst + d;
 }
@@ -288,7 +288,7 @@ O move_dispatch(I first, I last, O dst,
                 bcd::true_type const& /*use_memmove*/)
 {
    typedef typename ::boost::container::iterator_traits<I>::value_type value_type;
-   const std::size_t d = boost::container::iterator_distance(first, last);
+   const std::size_t d = boost::container::iterator_udistance(first, last);
    ::memmove(boost::container::dtl::addressof(*dst), boost::container::dtl::addressof(*first), sizeof(value_type)*d );
    return dst + d;
 }
@@ -320,7 +320,7 @@ BDO move_backward_dispatch(BDI first, BDI last, BDO dst,
                            bcd::true_type const& /*use_memmove*/)
 {
     typedef typename ::boost::container::iterator_traits<BDI>::value_type value_type;
-    const std::size_t d = boost::container::iterator_distance(first, last);
+    const std::size_t d = boost::container::iterator_udistance(first, last);
     BDO foo(dst - d);
     ::memmove(boost::container::dtl::addressof(*foo), boost::container::dtl::addressof(*first), sizeof(value_type) * d);
     return foo;

include/boost/container/deque.hpp

@@ -114,6 +114,7 @@ class deque_iterator
    typedef std::random_access_iterator_tag                                          iterator_category;
    typedef typename boost::intrusive::pointer_traits<Pointer>::element_type         value_type;
    typedef typename boost::intrusive::pointer_traits<Pointer>::difference_type      difference_type;
+   typedef typename boost::intrusive::pointer_traits<Pointer>::size_type            size_type;
    typedef typename if_c
       < IsConst
       , typename boost::intrusive::pointer_traits<Pointer>::template
@@ -151,6 +152,10 @@ class deque_iterator
       : m_cur(x), m_first(*y), m_last(*y + block_size), m_node(y)
    {}
 
+   BOOST_CONTAINER_FORCEINLINE deque_iterator(val_alloc_ptr x, index_pointer y, size_type block_size) BOOST_NOEXCEPT_OR_NOTHROW
+      : m_cur(x), m_first(*y), m_last(*y + difference_type(block_size)), m_node(y)
+   {}
+
    BOOST_CONTAINER_FORCEINLINE deque_iterator() BOOST_NOEXCEPT_OR_NOTHROW
       : m_cur(), m_first(), m_last(), m_node()  //Value initialization to achieve "null iterators" (N3644)
    {}
@@ -186,7 +191,7 @@ class deque_iterator
       if(!this->m_cur && !x.m_cur){
          return 0;
       }
-      const difference_type block_size = this->m_last - this->m_first;
+      const difference_type block_size = m_last - m_first;
       BOOST_ASSERT(block_size);
       return block_size * (this->m_node - x.m_node - 1) +
          (this->m_cur - this->m_first) + (x.m_last - x.m_cur);
@@ -238,15 +243,15 @@ class deque_iterator
          return *this;
       BOOST_ASSERT(!!m_cur);
       difference_type offset = n + (this->m_cur - this->m_first);
-      const difference_type block_size = this->m_last - this->m_first;
+      const difference_type block_size = m_last - m_first;
       BOOST_ASSERT(block_size);
       if (offset >= 0 && offset < block_size)
-         this->m_cur += n;
+         this->m_cur += difference_type(n);
       else {
          difference_type node_offset =
          offset > 0 ? (offset / block_size)
                     : (-difference_type((-offset - 1) / block_size) - 1);
-         this->priv_set_node(this->m_node + node_offset, block_size);
+         this->priv_set_node(this->m_node + node_offset, size_type(block_size));
          this->m_cur = this->m_first +
          (offset - node_offset * block_size);
       }
@@ -269,6 +274,7 @@ class deque_iterator
       reference operator[](difference_type n) const BOOST_NOEXCEPT_OR_NOTHROW
       { return *(*this + n); }
 
+   //Comparisons
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
       friend bool operator==(const deque_iterator& l, const deque_iterator& r) BOOST_NOEXCEPT_OR_NOTHROW
       { return l.m_cur == r.m_cur; }
@@ -297,6 +303,9 @@ class deque_iterator
       friend deque_iterator operator+(difference_type n, deque_iterator x) BOOST_NOEXCEPT_OR_NOTHROW
       {  return x += n;  }
 
+   BOOST_CONTAINER_FORCEINLINE void priv_set_node(index_pointer new_node, size_type block_size) BOOST_NOEXCEPT_OR_NOTHROW
+   {  return this->priv_set_node(new_node, difference_type(block_size)); }
+
    BOOST_CONTAINER_FORCEINLINE void priv_set_node(index_pointer new_node, difference_type block_size) BOOST_NOEXCEPT_OR_NOTHROW
    {
       this->m_node = new_node;
@@ -346,6 +355,7 @@ class deque_base
    typedef Allocator                                                      allocator_type;
    typedef allocator_type                                         stored_allocator_type;
    typedef val_alloc_size                                         size_type;
+   typedef val_alloc_diff                                         difference_type;
 
    private:
    typedef typename get_deque_opt<Options>::type                  options_type;
@@ -357,6 +367,9 @@ class deque_base
    BOOST_CONSTEXPR BOOST_CONTAINER_FORCEINLINE static size_type get_block_size() BOOST_NOEXCEPT_OR_NOTHROW
       { return deque_block_size<val_alloc_val, options_type::block_bytes, options_type::block_size>::value; }
 
+   BOOST_CONSTEXPR BOOST_CONTAINER_FORCEINLINE static val_alloc_diff get_block_ssize() BOOST_NOEXCEPT_OR_NOTHROW
+      { return val_alloc_diff((get_block_size)()); }
+
    typedef deque_value_traits<val_alloc_val>             traits_t;
    typedef ptr_alloc_t                                   map_allocator_type;
 
@@ -418,8 +431,8 @@ class deque_base
          this->members_.m_map_size = dtl::max_value((size_type) InitialMapSize, num_nodes + 2);
          this->members_.m_map = this->priv_allocate_map(this->members_.m_map_size);
 
-         ptr_alloc_ptr nstart = this->members_.m_map + (this->members_.m_map_size - num_nodes) / 2;
+         ptr_alloc_ptr nstart = this->members_.m_map + difference_type(this->members_.m_map_size - num_nodes) / 2;
-         ptr_alloc_ptr nfinish = nstart + num_nodes;
+         ptr_alloc_ptr nfinish = nstart + difference_type(num_nodes);
 
          BOOST_TRY {
             this->priv_create_nodes(nstart, nfinish);
@@ -435,8 +448,7 @@ class deque_base
          this->members_.m_start.priv_set_node(nstart, get_block_size());
          this->members_.m_finish.priv_set_node(nfinish - 1, get_block_size());
          this->members_.m_start.m_cur = this->members_.m_start.m_first;
-         this->members_.m_finish.m_cur = this->members_.m_finish.m_first +
+         this->members_.m_finish.m_cur = this->members_.m_finish.m_first + difference_type(num_elements % get_block_size());
-                        num_elements % get_block_size();
 //      }
    }
 
@@ -538,6 +550,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    typedef deque_base<typename real_allocator<T, Allocator>::type, Options> Base;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    typedef typename real_allocator<T, Allocator>::type ValAllocator;
+   typedef constant_iterator<T> c_it;
 
    public:
 
@@ -570,10 +583,12 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
 
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
+   using Base::get_block_ssize;
+
    public:
 
-   BOOST_CONSTEXPR BOOST_CONTAINER_FORCEINLINE static size_type get_block_size() BOOST_NOEXCEPT_OR_NOTHROW
+   using Base::get_block_size;
-      { return Base::get_block_size(); }
+
 
    //////////////////////////////////////////////
    //
@@ -903,7 +918,6 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Linear to n.
    BOOST_CONTAINER_FORCEINLINE void assign(size_type n, const T& val)
    {
-      typedef constant_iterator<value_type, difference_type> c_it;
       this->assign(c_it(val, n), c_it());
    }
 
@@ -946,10 +960,10 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          >::type * = 0
       )
    {
-      const size_type len = boost::container::iterator_distance(first, last);
+      const size_type len = boost::container::iterator_udistance(first, last);
       if (len > size()) {
          FwdIt mid = first;
-         boost::container::iterator_advance(mid, this->size());
+         boost::container::iterator_uadvance(mid, this->size());
          boost::container::copy(first, mid, begin());
          this->insert(this->cend(), mid, last);
       }
@@ -1143,7 +1157,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    //! <b>Complexity</b>: Constant.
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
       size_type size() const BOOST_NOEXCEPT_OR_NOTHROW
-      { return this->members_.m_finish - this->members_.m_start; }
+      { return size_type(this->members_.m_finish - this->members_.m_start); }
 
    //! <b>Effects</b>: Returns the largest possible size of the deque.
    //!
@@ -1202,7 +1216,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    {
       const size_type len = size();
       if (new_size < len)
-         this->erase(this->members_.m_start + new_size, this->members_.m_finish);
+         this->erase(this->members_.m_start + difference_type(new_size), this->members_.m_finish);
       else
          this->insert(this->members_.m_finish, new_size - len, x);
    }
@@ -1335,7 +1349,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->size() >= n);
-      return iterator(this->begin()+n);
+      return iterator(this->begin()+difference_type(n));
    }
 
    //! <b>Requires</b>: size() >= n.
@@ -1353,7 +1367,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->size() >= n);
-      return const_iterator(this->cbegin()+n);
+      return const_iterator(this->cbegin()+difference_type(n));
    }
 
    //! <b>Requires</b>: begin() <= p <= end().
@@ -1649,7 +1663,6 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    BOOST_CONTAINER_FORCEINLINE iterator insert(const_iterator pos, size_type n, const value_type& x)
    {
       //Range check of p is done by insert()
-      typedef constant_iterator<value_type, difference_type> c_it;
       return this->insert(pos, c_it(x, n), c_it());
    }
 
@@ -1681,7 +1694,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          it = this->emplace(it, *first);
          ++it;
       }
-      it -= n;
+      it -= difference_type(n);
       return it;
    }
 
@@ -1717,7 +1730,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
       dtl::insert_range_proxy<ValAllocator, FwdIt, iterator> proxy(first);
-      return priv_insert_aux_impl(p, boost::container::iterator_distance(first, last), proxy);
+      return priv_insert_aux_impl(p, boost::container::iterator_udistance(first, last), proxy);
    }
    #endif
 
@@ -1772,7 +1785,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       BOOST_ASSERT(this->priv_in_range(pos));
       iterator next = pos.unconst();
       ++next;
-      size_type index = pos - this->members_.m_start;
+      size_type index = size_type(pos - this->members_.m_start);
       if (index < (this->size()/2)) {
          boost::container::move_backward(this->begin(), pos.unconst(), next);
          pop_front();
@@ -1781,7 +1794,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          boost::container::move(next, this->end(), pos.unconst());
          pop_back();
       }
-      return this->members_.m_start + index;
+      return this->members_.m_start + difference_type(index);
    }
 
    //! <b>Effects</b>: Erases the elements pointed by [first, last).
@@ -1805,19 +1818,19 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          const size_type elems_before = static_cast<size_type>(first - this->members_.m_start);
          if (elems_before < (this->size() - n) - elems_before) {
             boost::container::move_backward(begin(), first.unconst(), last.unconst());
-            iterator new_start = this->members_.m_start + n;
+            iterator new_start = this->members_.m_start + difference_type(n);
             this->priv_destroy_range(this->members_.m_start, new_start);
             this->priv_destroy_nodes(this->members_.m_start.m_node, new_start.m_node);
             this->members_.m_start = new_start;
          }
          else {
             boost::container::move(last.unconst(), end(), first.unconst());
-            iterator new_finish = this->members_.m_finish - n;
+            iterator new_finish = this->members_.m_finish - difference_type(n);
             this->priv_destroy_range(new_finish, this->members_.m_finish);
             this->priv_destroy_nodes(new_finish.m_node + 1, this->members_.m_finish.m_node + 1);
             this->members_.m_finish = new_finish;
          }
-         return this->members_.m_start + elems_before;
+         return this->members_.m_start + difference_type(elems_before);
       }
    }
 
@@ -1848,7 +1861,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          for (index_pointer node = this->members_.m_start.m_node + 1;
                node < this->members_.m_finish.m_node;
                ++node) {
-            this->priv_destroy_range(*node, *node + get_block_size());
+            this->priv_destroy_range(*node, *node + get_block_ssize());
             this->priv_deallocate_node(*node);
          }
 
@@ -1929,7 +1942,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          this->clear();
       }
       else {
-         iterator new_finish = this->members_.m_finish - n;
+         iterator new_finish = this->members_.m_finish - difference_type(n);
          this->priv_destroy_range(new_finish, this->members_.m_finish);
          this->priv_destroy_nodes(new_finish.m_node + 1, this->members_.m_finish.m_node + 1);
          this->members_.m_finish = new_finish;
@@ -2051,7 +2064,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    iterator priv_insert_aux_impl(const_iterator p, size_type n, InsertProxy proxy)
    {
       iterator pos(p.unconst());
-      const size_type pos_n = p - this->cbegin();
+      const size_type pos_n = size_type(p - this->cbegin());
       if(!this->members_.m_map){
          this->priv_initialize_map(0);
          pos = this->begin();
@@ -2067,18 +2080,18 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
             this->members_.m_start = new_start;
          }
          else{
-            pos = this->members_.m_start + elemsbefore;
+            pos = this->members_.m_start + difference_type(elemsbefore);
             if (elemsbefore >= n) {
-               const iterator start_n = this->members_.m_start + n;
+               const iterator start_n = this->members_.m_start + difference_type(n);
                ::boost::container::uninitialized_move_alloc
                   (this->alloc(), this->members_.m_start, start_n, new_start);
                this->members_.m_start = new_start;
                boost::container::move(start_n, pos, old_start);
-               proxy.copy_n_and_update(this->alloc(), pos - n, n);
+               proxy.copy_n_and_update(this->alloc(), pos - difference_type(n), n);
             }
             else {
                const size_type mid_count = n - elemsbefore;
-               const iterator mid_start = old_start - mid_count;
+               const iterator mid_start = old_start - difference_type(mid_count);
                proxy.uninitialized_copy_n_and_update(this->alloc(), mid_start, mid_count);
                this->members_.m_start = mid_start;
                ::boost::container::uninitialized_move_alloc
@@ -2097,7 +2110,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
             this->members_.m_finish = new_finish;
          }
          else{
-            pos = old_finish - elemsafter;
+            pos = old_finish - difference_type(elemsafter);
             if (elemsafter >= n) {
                iterator finish_n = old_finish - difference_type(n);
                ::boost::container::uninitialized_move_alloc
@@ -2109,13 +2122,13 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
             else {
                const size_type raw_gap = n - elemsafter;
                ::boost::container::uninitialized_move_alloc
-                  (this->alloc(), pos, old_finish, old_finish + raw_gap);
+                  (this->alloc(), pos, old_finish, old_finish + difference_type(raw_gap));
                BOOST_TRY{
                   proxy.copy_n_and_update(this->alloc(), pos, elemsafter);
                   proxy.uninitialized_copy_n_and_update(this->alloc(), old_finish, raw_gap);
                }
                BOOST_CATCH(...){
-                  this->priv_destroy_range(old_finish, old_finish + elemsafter);
+                  this->priv_destroy_range(old_finish, old_finish + difference_type(elemsafter));
                   BOOST_RETHROW
                }
                BOOST_CATCH_END
@@ -2123,7 +2136,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
             }
          }
       }
-      return this->begin() + pos_n;
+      return this->begin() + difference_type(pos_n);
    }
 
    template <class InsertProxy>
@@ -2137,7 +2150,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       iterator old_finish = this->members_.m_finish;
       proxy.uninitialized_copy_n_and_update(this->alloc(), old_finish, n);
       this->members_.m_finish = new_finish;
-      return iterator(this->members_.m_finish - n);
+      return iterator(this->members_.m_finish - difference_type(n));
    }
 
    template <class InsertProxy>
@@ -2155,7 +2168,6 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
 
    BOOST_CONTAINER_FORCEINLINE iterator priv_fill_insert(const_iterator pos, size_type n, const value_type& x)
    {
-      typedef constant_iterator<value_type, difference_type> c_it;
       return this->insert(pos, c_it(x, n), c_it());
    }
 
@@ -2167,7 +2179,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       BOOST_TRY {
          for ( ; cur < this->members_.m_finish.m_node; ++cur){
             boost::container::uninitialized_fill_alloc
-               (this->alloc(), *cur, *cur + get_block_size(), value);
+               (this->alloc(), *cur, *cur + get_block_ssize(), value);
          }
          boost::container::uninitialized_fill_alloc
             (this->alloc(), this->members_.m_finish.m_first, this->members_.m_finish.m_cur, value);
@@ -2198,14 +2210,14 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
    void priv_range_initialize(FwdIt first, FwdIt last, typename iterator_disable_if_tag<FwdIt, std::input_iterator_tag>::type* =0)
    {
       size_type n = 0;
-      n = boost::container::iterator_distance(first, last);
+      n = boost::container::iterator_udistance(first, last);
       this->priv_initialize_map(n);
 
       index_pointer cur_node = this->members_.m_start.m_node;
       BOOST_TRY {
          for (; cur_node < this->members_.m_finish.m_node; ++cur_node) {
             FwdIt mid = first;
-            boost::container::iterator_advance(mid, get_block_size());
+            boost::container::iterator_uadvance(mid, get_block_size());
             ::boost::container::uninitialized_copy_alloc(this->alloc(), first, mid, *cur_node);
             first = mid;
          }
@@ -2247,11 +2259,10 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
 
    iterator priv_reserve_elements_at_front(size_type n)
    {
-      size_type vacancies = this->members_.m_start.m_cur - this->members_.m_start.m_first;
+      size_type vacancies = size_type(this->members_.m_start.m_cur - this->members_.m_start.m_first);
       if (n > vacancies){
          size_type new_elems = n-vacancies;
-         size_type new_nodes = (new_elems + get_block_size() - 1) /
+         size_type new_nodes = (new_elems + get_block_size() - 1u) / get_block_size();
-            get_block_size();
          size_type s = (size_type)(this->members_.m_start.m_node - this->members_.m_map);
          if (new_nodes > s){
             this->priv_reallocate_map(new_nodes, true);
@@ -2259,11 +2270,11 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
          size_type i = 1;
          BOOST_TRY {
             for (; i <= new_nodes; ++i)
-               *(this->members_.m_start.m_node - i) = this->priv_allocate_node();
+               *(this->members_.m_start.m_node - difference_type(i)) = this->priv_allocate_node();
          }
          BOOST_CATCH(...) {
             for (size_type j = 1; j < i; ++j)
-               this->priv_deallocate_node(*(this->members_.m_start.m_node - j));
+               this->priv_deallocate_node(*(this->members_.m_start.m_node - difference_type(j)));
             BOOST_RETHROW
          }
          BOOST_CATCH_END
@@ -2273,22 +2284,22 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
 
    iterator priv_reserve_elements_at_back(size_type n)
    {
-      size_type vacancies = (this->members_.m_finish.m_last - this->members_.m_finish.m_cur) - 1;
+      size_type vacancies = size_type(this->members_.m_finish.m_last - this->members_.m_finish.m_cur - 1);
       if (n > vacancies){
-         size_type new_elems = n - vacancies;
+         size_type new_elems = size_type(n - vacancies);
-         size_type new_nodes = (new_elems + get_block_size() - 1)/get_block_size();
+         size_type new_nodes = size_type(new_elems + get_block_size() - 1u)/get_block_size();
-         size_type s = (size_type)(this->members_.m_map_size - (this->members_.m_finish.m_node - this->members_.m_map));
+         size_type s = (size_type)(this->members_.m_map_size - size_type(this->members_.m_finish.m_node - this->members_.m_map));
          if (new_nodes + 1 > s){
             this->priv_reallocate_map(new_nodes, false);
          }
          size_type i = 1;
          BOOST_TRY {
             for (; i <= new_nodes; ++i)
-               *(this->members_.m_finish.m_node + i) = this->priv_allocate_node();
+               *(this->members_.m_finish.m_node + difference_type(i)) = this->priv_allocate_node();
          }
          BOOST_CATCH(...) {
             for (size_type j = 1; j < i; ++j)
-               this->priv_deallocate_node(*(this->members_.m_finish.m_node + j));
+               this->priv_deallocate_node(*(this->members_.m_finish.m_node + difference_type(j)));
             BOOST_RETHROW
          }
          BOOST_CATCH_END
@@ -2298,26 +2309,26 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
 
    void priv_reallocate_map(size_type nodes_to_add, bool add_at_front)
    {
-      size_type old_num_nodes = this->members_.m_finish.m_node - this->members_.m_start.m_node + 1;
+      size_type old_num_nodes = size_type(this->members_.m_finish.m_node - this->members_.m_start.m_node + 1);
       size_type new_num_nodes = old_num_nodes + nodes_to_add;
 
       index_pointer new_nstart;
       if (this->members_.m_map_size > 2 * new_num_nodes) {
-         new_nstart = this->members_.m_map + (this->members_.m_map_size - new_num_nodes) / 2
+         new_nstart = this->members_.m_map + difference_type(this->members_.m_map_size - new_num_nodes) / 2
-                           + (add_at_front ? nodes_to_add : 0);
+                           + difference_type(add_at_front ? nodes_to_add : 0u);
          if (new_nstart < this->members_.m_start.m_node)
             boost::container::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
          else
             boost::container::move_backward
-               (this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart + old_num_nodes);
+               (this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart + difference_type(old_num_nodes));
       }
       else {
          size_type new_map_size =
             this->members_.m_map_size + dtl::max_value(this->members_.m_map_size, nodes_to_add) + 2;
 
          index_pointer new_map = this->priv_allocate_map(new_map_size);
-         new_nstart = new_map + (new_map_size - new_num_nodes) / 2
+         new_nstart = new_map + difference_type(new_map_size - new_num_nodes) / 2
-                              + (add_at_front ? nodes_to_add : 0);
+                              + difference_type(add_at_front ? nodes_to_add : 0u);
          boost::container::move(this->members_.m_start.m_node, this->members_.m_finish.m_node + 1, new_nstart);
          this->priv_deallocate_map(this->members_.m_map, this->members_.m_map_size);
 
@@ -2326,7 +2337,7 @@ class deque : protected deque_base<typename real_allocator<T, Allocator>::type,
       }
 
       this->members_.m_start.priv_set_node(new_nstart, get_block_size());
-      this->members_.m_finish.priv_set_node(new_nstart + old_num_nodes - 1, get_block_size());
+      this->members_.m_finish.priv_set_node(new_nstart + difference_type(old_num_nodes - 1u), get_block_size());
    }
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 };

include/boost/container/detail/adaptive_node_pool_impl.hpp

@@ -535,7 +535,7 @@ class private_adaptive_node_pool_impl_common
                //Check that header offsets are correct
                hdr_offset_holder *hdr_off_holder = this->priv_first_subblock_from_block(const_cast<block_info_t *>(&*it), num_subblocks, real_block_alignment);
                for (size_type i = 0, max = num_subblocks; i < max; ++i) {
-                  const size_type offset = reinterpret_cast<char*>(const_cast<block_info_t *>(&*it)) - reinterpret_cast<char*>(hdr_off_holder);
+                  const size_type offset = size_type(reinterpret_cast<char*>(const_cast<block_info_t *>(&*it)) - reinterpret_cast<char*>(hdr_off_holder));
                   (void)offset;
                   BOOST_ASSERT(hdr_off_holder->hdr_offset == offset);
                   BOOST_ASSERT(0 == (reinterpret_cast<std::size_t>(hdr_off_holder) & (real_block_alignment - 1)));

include/boost/container/detail/advanced_insert_int.hpp

@@ -46,20 +46,19 @@ namespace boost { namespace container { namespace dtl {
 template<class Allocator, class FwdIt, class Iterator>
 struct move_insert_range_proxy
 {
-   typedef typename allocator_traits<Allocator>::size_type size_type;
    typedef typename allocator_traits<Allocator>::value_type value_type;
 
    BOOST_CONTAINER_FORCEINLINE explicit move_insert_range_proxy(FwdIt first)
       :  first_(first)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::uninitialized_move_alloc_n_source
          (a, this->first_, n, p);
    }
 
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::move_n_source(this->first_, n, p);
    }
@@ -71,19 +70,18 @@ struct move_insert_range_proxy
 template<class Allocator, class FwdIt, class Iterator>
 struct insert_range_proxy
 {
-   typedef typename allocator_traits<Allocator>::size_type size_type;
    typedef typename allocator_traits<Allocator>::value_type value_type;
 
    BOOST_CONTAINER_FORCEINLINE explicit insert_range_proxy(FwdIt first)
       :  first_(first)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::uninitialized_copy_alloc_n_source(a, this->first_, n, p);
    }
 
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n)
    {
       this->first_ = ::boost::container::copy_n_source(this->first_, n, p);
    }
@@ -95,17 +93,16 @@ struct insert_range_proxy
 template<class Allocator, class Iterator>
 struct insert_n_copies_proxy
 {
-   typedef typename allocator_traits<Allocator>::size_type size_type;
    typedef typename allocator_traits<Allocator>::value_type value_type;
 
    BOOST_CONTAINER_FORCEINLINE explicit insert_n_copies_proxy(const value_type &v)
       :  v_(v)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {  boost::container::uninitialized_fill_alloc_n(a, v_, n, p);  }
 
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
    {
       while (n){
          --n;
@@ -121,14 +118,13 @@ template<class Allocator, class Iterator>
 struct insert_value_initialized_n_proxy
 {
    typedef ::boost::container::allocator_traits<Allocator> alloc_traits;
-   typedef typename allocator_traits<Allocator>::size_type size_type;
    typedef typename allocator_traits<Allocator>::value_type value_type;
    typedef typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type storage_t;
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {  boost::container::uninitialized_value_init_alloc_n(a, n, p);  }
 
-   void copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   void copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {
       while (n){
          --n;
@@ -146,14 +142,13 @@ template<class Allocator, class Iterator>
 struct insert_default_initialized_n_proxy
 {
    typedef ::boost::container::allocator_traits<Allocator> alloc_traits;
-   typedef typename allocator_traits<Allocator>::size_type size_type;
    typedef typename allocator_traits<Allocator>::value_type value_type;
    typedef typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type storage_t;
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {  boost::container::uninitialized_default_init_alloc_n(a, n, p);  }
 
-   void copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   void copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {
       if(!is_pod<value_type>::value){
          while (n){
@@ -173,7 +168,6 @@ template<class Allocator, class Iterator>
 struct insert_copy_proxy
 {
    typedef boost::container::allocator_traits<Allocator> alloc_traits;
-   typedef typename alloc_traits::size_type size_type;
    typedef typename alloc_traits::value_type value_type;
 
    static const bool single_value = true;
@@ -182,13 +176,13 @@ struct insert_copy_proxy
       :  v_(v)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), v_);
    }
 
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       *p = v_;
@@ -202,7 +196,6 @@ template<class Allocator, class Iterator>
 struct insert_move_proxy
 {
    typedef boost::container::allocator_traits<Allocator> alloc_traits;
-   typedef typename alloc_traits::size_type size_type;
    typedef typename alloc_traits::value_type value_type;
 
    static const bool single_value = true;
@@ -211,13 +204,13 @@ struct insert_move_proxy
       :  v_(v)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::move(v_) );
    }
 
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, size_type n) const
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator p, std::size_t n) const
    {
       BOOST_ASSERT(n == 1);  (void)n;
       *p = ::boost::move(v_);
@@ -253,7 +246,6 @@ template<class Allocator, class Iterator, class ...Args>
 struct insert_nonmovable_emplace_proxy
 {
    typedef boost::container::allocator_traits<Allocator>   alloc_traits;
-   typedef typename alloc_traits::size_type        size_type;
    typedef typename alloc_traits::value_type       value_type;
    typedef typename build_number_seq<sizeof...(Args)>::type index_tuple_t;
 
@@ -263,12 +255,12 @@ struct insert_nonmovable_emplace_proxy
       : args_(args...)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {  this->priv_uninitialized_copy_some_and_update(a, index_tuple_t(), p, n);  }
 
    private:
    template<std::size_t ...IdxPack>
-   BOOST_CONTAINER_FORCEINLINE void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void priv_uninitialized_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
    {
       BOOST_ASSERT(n == 1); (void)n;
       alloc_traits::construct( a, boost::movelib::iterator_to_raw_pointer(p), ::boost::forward<Args>(get<IdxPack>(this->args_))... );
@@ -285,7 +277,6 @@ struct insert_emplace_proxy
    typedef insert_nonmovable_emplace_proxy<Allocator, Iterator, Args...> base_t;
    typedef boost::container::allocator_traits<Allocator>   alloc_traits;
    typedef typename base_t::value_type             value_type;
-   typedef typename base_t::size_type              size_type;
    typedef typename base_t::index_tuple_t          index_tuple_t;
 
    static const bool single_value = true;
@@ -294,13 +285,13 @@ struct insert_emplace_proxy
       : base_t(::boost::forward<Args>(args)...)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)
    {  this->priv_copy_some_and_update(a, index_tuple_t(), p, n);  }
 
    private:
 
    template<std::size_t ...IdxPack>
-   BOOST_CONTAINER_FORCEINLINE void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, size_type n)
+   BOOST_CONTAINER_FORCEINLINE void priv_copy_some_and_update(Allocator &a, const index_tuple<IdxPack...>&, Iterator p, std::size_t n)
    {
       BOOST_ASSERT(n ==1); (void)n;
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;
@@ -386,7 +377,6 @@ template< class Allocator, class Iterator BOOST_MOVE_I##N BOOST_MOVE_CLASS##N >\
 struct insert_nonmovable_emplace_proxy##N\
 {\
    typedef boost::container::allocator_traits<Allocator> alloc_traits;\
-   typedef typename alloc_traits::size_type size_type;\
    typedef typename alloc_traits::value_type value_type;\
    \
    static const bool single_value = true;\
@@ -394,13 +384,13 @@ struct insert_nonmovable_emplace_proxy##N\
    BOOST_CONTAINER_FORCEINLINE explicit insert_nonmovable_emplace_proxy##N(BOOST_MOVE_UREF##N)\
       BOOST_MOVE_COLON##N BOOST_MOVE_FWD_INIT##N {}\
    \
-   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, size_type n)\
+   BOOST_CONTAINER_FORCEINLINE void uninitialized_copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
    {\
       BOOST_ASSERT(n == 1); (void)n;\
       alloc_traits::construct(a, boost::movelib::iterator_to_raw_pointer(p) BOOST_MOVE_I##N BOOST_MOVE_MFWD##N);\
    }\
    \
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator, size_type)\
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &, Iterator, std::size_t)\
    {  BOOST_ASSERT(false);   }\
    \
    protected:\
@@ -414,7 +404,6 @@ struct insert_emplace_proxy_arg##N\
    typedef insert_nonmovable_emplace_proxy##N\
       < Allocator, Iterator BOOST_MOVE_I##N BOOST_MOVE_TARG##N > base_t;\
    typedef typename base_t::value_type value_type;\
-   typedef typename base_t::size_type size_type;\
    typedef boost::container::allocator_traits<Allocator> alloc_traits;\
    \
    static const bool single_value = true;\
@@ -422,7 +411,7 @@ struct insert_emplace_proxy_arg##N\
    BOOST_CONTAINER_FORCEINLINE explicit insert_emplace_proxy_arg##N(BOOST_MOVE_UREF##N)\
       : base_t(BOOST_MOVE_FWD##N){}\
    \
-   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, size_type n)\
+   BOOST_CONTAINER_FORCEINLINE void copy_n_and_update(Allocator &a, Iterator p, std::size_t n)\
    {\
       BOOST_ASSERT(n == 1); (void)n;\
       typename dtl::aligned_storage<sizeof(value_type), dtl::alignment_of<value_type>::value>::type v;\

include/boost/container/detail/construct_in_place.hpp

@@ -34,26 +34,26 @@ template<class Allocator, class T, class InpIt>
 BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T* dest, InpIt source)
 {     boost::container::allocator_traits<Allocator>::construct(a, dest, *source);  }
 
-template<class Allocator, class T, class U, class D>
+template<class Allocator, class T, class U>
-BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, value_init_construct_iterator<U, D>)
+BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, value_init_construct_iterator<U>)
 {
    boost::container::allocator_traits<Allocator>::construct(a, dest);
 }
 
-template <class T, class Difference>
+template <class T>
 class default_init_construct_iterator;
 
-template<class Allocator, class T, class U, class D>
+template<class Allocator, class T, class U>
-BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, default_init_construct_iterator<U, D>)
+BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, default_init_construct_iterator<U>)
 {
    boost::container::allocator_traits<Allocator>::construct(a, dest, default_init);
 }
 
-template <class T, class EmplaceFunctor, class Difference>
+template <class T, class EmplaceFunctor>
 class emplace_iterator;
 
-template<class Allocator, class T, class U, class EF, class D>
+template<class Allocator, class T, class U, class EF>
-BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, emplace_iterator<U, EF, D> ei)
+BOOST_CONTAINER_FORCEINLINE void construct_in_place(Allocator &a, T *dest, emplace_iterator<U, EF> ei)
 {
    ei.construct_in_place(a, dest);
 }
@@ -64,28 +64,28 @@ template<class DstIt, class InpIt>
 BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, InpIt source)
 {  *dest = *source;  }
 
-template<class DstIt, class U, class D>
+template<class DstIt, class U>
-BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, value_init_construct_iterator<U, D>)
+BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, value_init_construct_iterator<U>)
 {
    dtl::value_init<U> val;
    *dest = boost::move(val.get());
 }
 
-template <class DstIt, class Difference>
+template <class DstIt>
 class default_init_construct_iterator;
 
 template<class DstIt, class U, class D>
-BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, default_init_construct_iterator<U, D>)
+BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, default_init_construct_iterator<U>)
 {
    U u;
    *dest = boost::move(u);
 }
 
-template <class T, class EmplaceFunctor, class Difference>
+template <class T, class EmplaceFunctor>
 class emplace_iterator;
 
-template<class DstIt, class U, class EF, class D>
+template<class DstIt, class U, class EF>
-BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, emplace_iterator<U, EF, D> ei)
+BOOST_CONTAINER_FORCEINLINE void assign_in_place(DstIt dest, emplace_iterator<U, EF> ei)
 {
    ei.assign_in_place(dest);
 }

include/boost/container/detail/copy_move_algo.hpp

@@ -174,14 +174,15 @@ template
     typename F> // F models ForwardIterator
 BOOST_CONTAINER_FORCEINLINE F memmove(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
-   typedef typename boost::container::iterator_traits<I>::value_type value_type;
+   typedef typename boost::container::iterator_traits<I>::value_type      value_type;
+   typedef typename boost::container::iterator_traits<F>::difference_type r_difference_type;
    value_type *const dest_raw = boost::movelib::iterator_to_raw_pointer(r);
    const value_type *const beg_raw = boost::movelib::iterator_to_raw_pointer(f);
    const value_type *const end_raw = boost::movelib::iterator_to_raw_pointer(l);
    if(BOOST_LIKELY(beg_raw != end_raw && dest_raw && beg_raw)){
-      const typename boost::container::iterator_traits<I>::difference_type n = end_raw - beg_raw;
+      const std::size_t n = std::size_t(end_raw - beg_raw)   ;
       std::memmove(dest_raw, beg_raw, sizeof(value_type)*n);
-      r += n;
+      r += static_cast<r_difference_type>(n);
    }
    return r;
 }
@@ -193,9 +194,10 @@ template
 BOOST_CONTAINER_FORCEINLINE F memmove_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
-   if(BOOST_LIKELY(n)){
+   typedef typename boost::container::iterator_traits<F>::difference_type r_difference_type;
+   if(BOOST_LIKELY(n != 0)){
       std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
-      r += n;
+      r += static_cast<r_difference_type>(n);
    }
 
    return r;
@@ -203,29 +205,31 @@ BOOST_CONTAINER_FORCEINLINE F memmove_n(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 
 template
    <typename I, // I models InputIterator
-    typename U, // U models unsigned integral constant
     typename F> // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE I memmove_n_source(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+BOOST_CONTAINER_FORCEINLINE I memmove_n_source(I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
-   if(BOOST_LIKELY(n)){
+   if(BOOST_LIKELY(n != 0)){
       typedef typename boost::container::iterator_traits<I>::value_type value_type;
+      typedef typename boost::container::iterator_traits<I>::difference_type i_difference_type;
       std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
-      f += n;
+      f += static_cast<i_difference_type>(n);
    }
    return f;
 }
 
 template
    <typename I, // I models InputIterator
-    typename U, // U models unsigned integral constant
     typename F> // F models ForwardIterator
-BOOST_CONTAINER_FORCEINLINE I memmove_n_source_dest(I f, U n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
+BOOST_CONTAINER_FORCEINLINE I memmove_n_source_dest(I f, std::size_t n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
-   if(BOOST_LIKELY(n)){
+   typedef typename boost::container::iterator_traits<F>::difference_type i_difference_type;
+   typedef typename boost::container::iterator_traits<F>::difference_type f_difference_type;
+
+   if(BOOST_LIKELY(n != 0)){
       std::memmove(boost::movelib::iterator_to_raw_pointer(r), boost::movelib::iterator_to_raw_pointer(f), sizeof(value_type)*n);
-      f += n;
+      f += i_difference_type(n);
-      r += n;
+      r += f_difference_type(n);
    }
    return f;
 }
@@ -338,7 +342,7 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
-   uninitialized_move_alloc_n(Allocator &a, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
+   uninitialized_move_alloc_n(Allocator &a, I f, std::size_t n, F r)
 {
    F back = r;
    BOOST_TRY{
@@ -363,7 +367,7 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
-   uninitialized_move_alloc_n(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   uninitialized_move_alloc_n(Allocator &, I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -384,7 +388,7 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, I>::type
-   uninitialized_move_alloc_n_source(Allocator &a, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
+   uninitialized_move_alloc_n_source(Allocator &a, I f, std::size_t n, F r)
 {
    F back = r;
    BOOST_TRY{
@@ -409,7 +413,7 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_constructible<I, F, I>::type
-   uninitialized_move_alloc_n_source(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   uninitialized_move_alloc_n_source(Allocator &, I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n_source(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -475,7 +479,7 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, F>::type
-   uninitialized_copy_alloc_n(Allocator &a, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
+   uninitialized_copy_alloc_n(Allocator &a, I f, std::size_t n, F r)
 {
    F back = r;
    BOOST_TRY{
@@ -500,7 +504,7 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_constructible<I, F, F>::type
-   uninitialized_copy_alloc_n(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   uninitialized_copy_alloc_n(Allocator &, I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -521,7 +525,7 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 inline typename dtl::disable_if_memtransfer_copy_constructible<I, F, I>::type
-   uninitialized_copy_alloc_n_source(Allocator &a, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
+   uninitialized_copy_alloc_n_source(Allocator &a, I f, std::size_t n, F r)
 {
    F back = r;
    BOOST_TRY{
@@ -545,7 +549,7 @@ template
     typename I, // I models InputIterator
     typename F> // F models ForwardIterator
 BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_constructible<I, F, I>::type
-   uninitialized_copy_alloc_n_source(Allocator &, I f, typename boost::container::allocator_traits<Allocator>::size_type n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   uninitialized_copy_alloc_n_source(Allocator &, I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n_source(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -565,7 +569,7 @@ template
    <typename Allocator,
     typename F> // F models ForwardIterator
 inline typename dtl::disable_if_memzero_initializable<F, F>::type
-   uninitialized_value_init_alloc_n(Allocator &a, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
+   uninitialized_value_init_alloc_n(Allocator &a, std::size_t n, F r)
 {
    F back = r;
    BOOST_TRY{
@@ -589,12 +593,14 @@ template
    <typename Allocator,
     typename F> // F models ForwardIterator
 BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memzero_initializable<F, F>::type
-   uninitialized_value_init_alloc_n(Allocator &, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
+   uninitialized_value_init_alloc_n(Allocator &, std::size_t n, F r)
 {
    typedef typename boost::container::iterator_traits<F>::value_type value_type;
-   if (BOOST_LIKELY(n)){
+   typedef typename boost::container::iterator_traits<F>::difference_type r_difference_type;
+
+   if (BOOST_LIKELY(n != 0)){
       std::memset((void*)boost::movelib::iterator_to_raw_pointer(r), 0, sizeof(value_type)*n);
-      r += n;
+      r += static_cast<r_difference_type>(n);
    }
    return r;
 }
@@ -615,7 +621,7 @@ BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memzero_initializable<F, F>:
 template
    <typename Allocator,
     typename F> // F models ForwardIterator
-inline F uninitialized_default_init_alloc_n(Allocator &a, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
+inline F uninitialized_default_init_alloc_n(Allocator &a, std::size_t n, F r)
 {
    F back = r;
    BOOST_TRY{
@@ -688,7 +694,7 @@ template
    <typename Allocator,
     typename T,
     typename F> // F models ForwardIterator
-inline F uninitialized_fill_alloc_n(Allocator &a, const T &v, typename boost::container::allocator_traits<Allocator>::size_type n, F r)
+inline F uninitialized_fill_alloc_n(Allocator &a, const T &v, std::size_t n, F r)
 {
    F back = r;
    BOOST_TRY{
@@ -786,10 +792,9 @@ inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
 
 template
 <typename I,   // I models InputIterator
-typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
-   copy_n_source(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   copy_n_source(I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n_source(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -800,10 +805,9 @@ BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_assignable<
 
 template
 <typename I,   // I models InputIterator
-typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
-   copy_n_source_dest(I f, U n, F &r)
+   copy_n_source_dest(I f, std::size_t n, F &r)
 {
    while (n) {
       --n;
@@ -815,10 +819,9 @@ inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
 
 template
 <typename I,   // I models InputIterator
-typename U,   // U models unsigned integral constant
 typename F>   // F models ForwardIterator
 BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
-   copy_n_source_dest(I f, U n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
+   copy_n_source_dest(I f, std::size_t n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n_source_dest(f, n, r);  }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -903,8 +906,8 @@ BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_assignable<
    move_backward(I f, I l, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {
    typedef typename boost::container::iterator_traits<I>::value_type value_type;
-   const typename boost::container::iterator_traits<I>::difference_type n = boost::container::iterator_distance(f, l);
+   const std::size_t n = boost::container::iterator_udistance(f, l);
-   if (BOOST_LIKELY(n)){
+   if (BOOST_LIKELY(n != 0)){
       r -= n;
       std::memmove((boost::movelib::iterator_to_raw_pointer)(r), (boost::movelib::iterator_to_raw_pointer)(f), sizeof(value_type)*n);
    }
@@ -934,10 +937,9 @@ inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
 
 template
 <typename I    // I models InputIterator
-,typename U    // U models unsigned integral constant
 ,typename F>   // F models ForwardIterator
 BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
-   move_n_source_dest(I f, U n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
+   move_n_source_dest(I f, std::size_t n, F &r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n_source_dest(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -963,10 +965,9 @@ inline typename dtl::disable_if_memtransfer_copy_assignable<I, F, I>::type
 
 template
 <typename I    // I models InputIterator
-,typename U    // U models unsigned integral constant
 ,typename F>   // F models ForwardIterator
 BOOST_CONTAINER_FORCEINLINE typename dtl::enable_if_memtransfer_copy_assignable<I, F, I>::type
-   move_n_source(I f, U n, F r) BOOST_NOEXCEPT_OR_NOTHROW
+   move_n_source(I f, std::size_t n, F r) BOOST_NOEXCEPT_OR_NOTHROW
 {  return dtl::memmove_n_source(f, n, r); }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -1010,15 +1011,14 @@ template
    ,typename G // G models ForwardIterator
    >
 inline typename dtl::disable_if_memtransfer_copy_assignable<F, G, void>::type
-   deep_swap_alloc_n( Allocator &a, F short_range_f, typename allocator_traits<Allocator>::size_type n_i
+   deep_swap_alloc_n( Allocator &a, F short_range_f, std::size_t  n_i, G large_range_f, std::size_t n_j)
-                    , G large_range_f, typename allocator_traits<Allocator>::size_type n_j)
 {
-   typename allocator_traits<Allocator>::size_type n = 0;
+   std::size_t n = 0;
    for (; n != n_i ; ++short_range_f, ++large_range_f, ++n){
       boost::adl_move_swap(*short_range_f, *large_range_f);
    }
-   boost::container::uninitialized_move_alloc_n(a, large_range_f, n_j - n_i, short_range_f);  // may throw
+   boost::container::uninitialized_move_alloc_n(a, large_range_f, std::size_t(n_j - n_i), short_range_f);  // may throw
-   boost::container::destroy_alloc_n(a, large_range_f, n_j - n_i);
+   boost::container::destroy_alloc_n(a, large_range_f, std::size_t(n_j - n_i));
 }
 
 static const std::size_t DeepSwapAllocNMaxStorage = std::size_t(1) << std::size_t(11); //2K bytes
@@ -1032,8 +1032,7 @@ template
 inline typename dtl::enable_if_c
    < dtl::is_memtransfer_copy_assignable<F, G>::value && (MaxTmpBytes <= DeepSwapAllocNMaxStorage) && false
    , void>::type
-   deep_swap_alloc_n( Allocator &a, F short_range_f, typename allocator_traits<Allocator>::size_type n_i
+   deep_swap_alloc_n( Allocator &a, F short_range_f, std::size_t n_i, G large_range_f, std::size_t n_j)
-                    , G large_range_f, typename allocator_traits<Allocator>::size_type n_j)
 {
    typedef typename allocator_traits<Allocator>::value_type value_type;
    typedef typename dtl::aligned_storage
@@ -1047,10 +1046,10 @@ inline typename dtl::enable_if_c
    std::memcpy(stora_ptr, large_ptr, n_i_bytes);
    std::memcpy(large_ptr, short_ptr, n_i_bytes);
    std::memcpy(short_ptr, stora_ptr, n_i_bytes);
-   boost::container::iterator_advance(large_range_f, n_i);
+   boost::container::iterator_uadvance(large_range_f, n_i);
-   boost::container::iterator_advance(short_range_f, n_i);
+   boost::container::iterator_uadvance(short_range_f, n_i);
-   boost::container::uninitialized_move_alloc_n(a, large_range_f, n_j - n_i, short_range_f);  // may throw
+   boost::container::uninitialized_move_alloc_n(a, large_range_f, std::size_t(n_j - n_i), short_range_f);  // may throw
-   boost::container::destroy_alloc_n(a, large_range_f, n_j - n_i);
+   boost::container::destroy_alloc_n(a, large_range_f, std::size_t(n_j - n_i));
 }
 
 template
@@ -1062,8 +1061,7 @@ template
 inline typename dtl::enable_if_c
    < dtl::is_memtransfer_copy_assignable<F, G>::value && true//(MaxTmpBytes > DeepSwapAllocNMaxStorage)
    , void>::type
-   deep_swap_alloc_n( Allocator &a, F short_range_f, typename allocator_traits<Allocator>::size_type n_i
+   deep_swap_alloc_n( Allocator &a, F short_range_f, std::size_t n_i, G large_range_f, std::size_t n_j)
-                    , G large_range_f, typename allocator_traits<Allocator>::size_type n_j)
 {
    typedef typename allocator_traits<Allocator>::value_type value_type;
    typedef typename dtl::aligned_storage
@@ -1118,10 +1116,10 @@ inline typename dtl::enable_if_c
    std::memcpy(stora_ptr, large_ptr, szt_rem);
    std::memcpy(large_ptr, short_ptr, szt_rem);
    std::memcpy(short_ptr, stora_ptr, szt_rem);
-   boost::container::iterator_advance(large_range_f, n_i);
+   boost::container::iterator_uadvance(large_range_f, n_i);
-   boost::container::iterator_advance(short_range_f, n_i);
+   boost::container::iterator_uadvance(short_range_f, n_i);
-   boost::container::uninitialized_move_alloc_n(a, large_range_f, n_j - n_i, short_range_f);  // may throw
+   boost::container::uninitialized_move_alloc_n(a, large_range_f, std::size_t(n_j - n_i), short_range_f);  // may throw
-   boost::container::destroy_alloc_n(a, large_range_f, n_j - n_i);
+   boost::container::destroy_alloc_n(a, large_range_f, std::size_t(n_j - n_i));
 }
 
 
@@ -1136,16 +1134,15 @@ template
    ,typename I // F models InputIterator
    ,typename O // G models OutputIterator
    >
-void copy_assign_range_alloc_n( Allocator &a, I inp_start, typename allocator_traits<Allocator>::size_type n_i
+void copy_assign_range_alloc_n( Allocator &a, I inp_start, std::size_t n_i, O out_start, std::size_t n_o )
-                              , O out_start, typename allocator_traits<Allocator>::size_type n_o )
 {
    if (n_o < n_i){
       inp_start = boost::container::copy_n_source_dest(inp_start, n_o, out_start);     // may throw
-      boost::container::uninitialized_copy_alloc_n(a, inp_start, n_i - n_o, out_start);// may throw
+      boost::container::uninitialized_copy_alloc_n(a, inp_start, std::size_t(n_i - n_o), out_start);// may throw
    }
    else{
       out_start = boost::container::copy_n(inp_start, n_i, out_start);  // may throw
-      boost::container::destroy_alloc_n(a, out_start, n_o - n_i);
+      boost::container::destroy_alloc_n(a, out_start, std::size_t(n_o - n_i));
    }
 }
 
@@ -1160,16 +1157,15 @@ template
    ,typename I // F models InputIterator
    ,typename O // G models OutputIterator
    >
-void move_assign_range_alloc_n( Allocator &a, I inp_start, typename allocator_traits<Allocator>::size_type n_i
+void move_assign_range_alloc_n( Allocator &a, I inp_start, std::size_t n_i, O out_start, std::size_t n_o )
-                              , O out_start, typename allocator_traits<Allocator>::size_type n_o )
 {
    if (n_o < n_i){
       inp_start = boost::container::move_n_source_dest(inp_start, n_o, out_start);  // may throw
-      boost::container::uninitialized_move_alloc_n(a, inp_start, n_i - n_o, out_start);  // may throw
+      boost::container::uninitialized_move_alloc_n(a, inp_start, std::size_t(n_i - n_o), out_start);  // may throw
    }
    else{
       out_start = boost::container::move_n(inp_start, n_i, out_start);  // may throw
-      boost::container::destroy_alloc_n(a, out_start, n_o - n_i);
+      boost::container::destroy_alloc_n(a, out_start, std::size_t(n_o - n_i));
    }
 }
 
@@ -1196,7 +1192,7 @@ void uninitialized_move_and_insert_alloc
    , F pos
    , F last
    , O d_first
-   , typename allocator_traits<Allocator>::size_type n
+   , std::size_t n
    , InsertionProxy insert_range_proxy)
 {
    typedef typename array_destructor<Allocator, F>::type array_destructor_t;
@@ -1228,7 +1224,7 @@ void expand_forward_and_insert_alloc
    ( Allocator &a
    , F pos
    , F last
-   , typename allocator_traits<Allocator>::size_type n
+   , std::size_t n
    , InsertionProxy insert_range_proxy)
 {
    typedef typename array_destructor<Allocator, F>::type array_destructor_t;
@@ -1240,8 +1236,7 @@ void expand_forward_and_insert_alloc
       insert_range_proxy.uninitialized_copy_n_and_update(a, last, n);
    }
    else{
-      typedef typename allocator_traits<Allocator>::size_type alloc_size_type;
+      const std::size_t elems_after = static_cast<std::size_t>(last - pos);
-      const alloc_size_type elems_after = static_cast<alloc_size_type>(last - pos);
       if(elems_after >= n){
          //New elements can be just copied.
          //Move to uninitialized memory last objects
@@ -1261,7 +1256,7 @@ void expand_forward_and_insert_alloc
          //Copy first new elements in pos (gap is still there)
          insert_range_proxy.copy_n_and_update(a, pos, elems_after);
          //Copy to the beginning of the unallocated zone the last new elements (the gap is closed).
-         insert_range_proxy.uninitialized_copy_n_and_update(a, last, n - elems_after);
+         insert_range_proxy.uninitialized_copy_n_and_update(a, last, std::size_t(n - elems_after));
          on_exception.release();
       }
    }

include/boost/container/detail/destroyers.hpp

@@ -83,9 +83,8 @@ struct null_scoped_deallocator
 {
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    typedef typename AllocTraits::pointer    pointer;
-   typedef typename AllocTraits::size_type  size_type;
 
-   null_scoped_deallocator(pointer, Allocator&, size_type)
+   null_scoped_deallocator(pointer, Allocator&, std::size_t)
    {}
 
    void release()
@@ -107,11 +106,11 @@ struct scoped_array_deallocator
    typedef typename AllocTraits::pointer    pointer;
    typedef typename AllocTraits::size_type  size_type;
 
-   scoped_array_deallocator(pointer p, Allocator& a, size_type length)
+   scoped_array_deallocator(pointer p, Allocator& a, std::size_t length)
       : m_ptr(p), m_alloc(a), m_length(length) {}
 
    ~scoped_array_deallocator()
-   {  if (m_ptr) m_alloc.deallocate(m_ptr, m_length);  }
+   {  if (m_ptr) m_alloc.deallocate(m_ptr, size_type(m_length));  }
 
    void release()
    {  m_ptr = 0; }
@@ -119,7 +118,7 @@ struct scoped_array_deallocator
    private:
    pointer     m_ptr;
    Allocator&  m_alloc;
-   size_type   m_length;
+   std::size_t m_length;
 };
 
 template <class Allocator>
@@ -127,9 +126,8 @@ struct null_scoped_array_deallocator
 {
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    typedef typename AllocTraits::pointer    pointer;
-   typedef typename AllocTraits::size_type  size_type;
 
-   null_scoped_array_deallocator(pointer, Allocator&, size_type)
+   null_scoped_array_deallocator(pointer, Allocator&, std::size_t)
    {}
 
    void release()
@@ -141,7 +139,6 @@ struct scoped_destroy_deallocator
 {
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    typedef typename AllocTraits::pointer    pointer;
-   typedef typename AllocTraits::size_type  size_type;
    typedef dtl::integral_constant<unsigned,
       boost::container::dtl::
          version<Allocator>::value>                          alloc_version;
@@ -181,23 +178,22 @@ struct scoped_destructor_n
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    typedef typename AllocTraits::pointer    pointer;
    typedef typename AllocTraits::value_type value_type;
-   typedef typename AllocTraits::size_type  size_type;
 
-   BOOST_CONTAINER_FORCEINLINE scoped_destructor_n(pointer p, Allocator& a, size_type n)
+   BOOST_CONTAINER_FORCEINLINE scoped_destructor_n(pointer p, Allocator& a, std::size_t n)
       : m_p(p), m_a(a), m_n(n)
    {}
 
    BOOST_CONTAINER_FORCEINLINE void release()
    {  m_p = 0; m_n = 0; }
 
-   BOOST_CONTAINER_FORCEINLINE void increment_size(size_type inc)
+   BOOST_CONTAINER_FORCEINLINE void increment_size(std::size_t inc)
    {  m_n += inc;   }
 
-   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(size_type inc)
+   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(std::size_t inc)
-   {  m_n += inc;   m_p -= inc;  }
+   {  m_n += inc;   m_p -= std::ptrdiff_t(inc);  }
 
-   BOOST_CONTAINER_FORCEINLINE void shrink_forward(size_type inc)
+   BOOST_CONTAINER_FORCEINLINE void shrink_forward(std::size_t inc)
-   {  m_n -= inc;   m_p += inc;  }
+   {  m_n -= inc;   m_p += std::ptrdiff_t(inc);  }
 
    ~scoped_destructor_n()
    {
@@ -214,7 +210,7 @@ struct scoped_destructor_n
    private:
    pointer     m_p;
    Allocator & m_a;
-   size_type   m_n;
+   std::size_t m_n;
 };
 
 //!A deleter for scoped_ptr that destroys
@@ -224,18 +220,17 @@ struct null_scoped_destructor_n
 {
    typedef boost::container::allocator_traits<Allocator> AllocTraits;
    typedef typename AllocTraits::pointer pointer;
-   typedef typename AllocTraits::size_type size_type;
 
-   BOOST_CONTAINER_FORCEINLINE null_scoped_destructor_n(pointer, Allocator&, size_type)
+   BOOST_CONTAINER_FORCEINLINE null_scoped_destructor_n(pointer, Allocator&, std::size_t)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void increment_size(size_type)
+   BOOST_CONTAINER_FORCEINLINE void increment_size(std::size_t)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(size_type)
+   BOOST_CONTAINER_FORCEINLINE void increment_size_backwards(std::size_t)
    {}
 
-   BOOST_CONTAINER_FORCEINLINE void shrink_forward(size_type)
+   BOOST_CONTAINER_FORCEINLINE void shrink_forward(std::size_t)
    {}
 
    BOOST_CONTAINER_FORCEINLINE void release()

include/boost/container/detail/flat_tree.hpp

@@ -212,15 +212,16 @@ template<class SequenceContainer, class Iterator, class Compare>
 BOOST_CONTAINER_FORCEINLINE void flat_tree_merge_unique  //has_merge_unique == false
    (SequenceContainer& dest, Iterator first, Iterator last, Compare comp, dtl::false_)
 {
-   typedef typename SequenceContainer::iterator    iterator;
+   typedef typename SequenceContainer::iterator          iterator;
-   typedef typename SequenceContainer::size_type   size_type;
+   typedef typename SequenceContainer::size_type         size_type;
+   typedef typename SequenceContainer::difference_type   difference_type;
 
    size_type const old_sz = dest.size();
    iterator const first_new = dest.insert(dest.cend(), first, last );
    iterator e = boost::movelib::inplace_set_unique_difference(first_new, dest.end(), dest.begin(), first_new, comp);
    dest.erase(e, dest.end());
    dtl::bool_<is_contiguous_container<SequenceContainer>::value> contiguous_tag;
-   (flat_tree_container_inplace_merge)(dest, dest.begin()+old_sz, comp, contiguous_tag);
+   (flat_tree_container_inplace_merge)(dest, dest.begin() + difference_type(old_sz), comp, contiguous_tag);
 }
 
 ///////////////////////////////////////
@@ -263,7 +264,7 @@ BOOST_CONTAINER_FORCEINLINE Iterator
    flat_tree_nth  // has_nth == false
       (SequenceContainer& cont, typename SequenceContainer::size_type n, dtl::false_)
 {
-   return cont.begin()+ n;
+   return cont.begin()+ typename SequenceContainer::difference_type(n);
 }
 
 ///////////////////////////////////////
@@ -1013,7 +1014,7 @@ class flat_tree
          : this->priv_insert_unique_prepare(hint, k, data);
 
       if(!ret.second){
-         ret.first  = this->nth(data.position - this->cbegin());
+         ret.first  = this->nth(size_type(data.position - this->cbegin()));
       }
       else{
          ret.first = this->m_data.m_seq.emplace(data.position, try_emplace_t(), ::boost::forward<KeyType>(key), ::boost::forward<Args>(args)...);
@@ -1079,7 +1080,7 @@ class flat_tree
          : this->priv_insert_unique_prepare(hint, k, data);\
       \
       if(!ret.second){\
-         ret.first  = this->nth(data.position - this->cbegin());\
+         ret.first  = this->nth(size_type(data.position - this->cbegin()));\
       }\
       else{\
          ret.first = this->m_data.m_seq.emplace(data.position, try_emplace_t(), ::boost::forward<KeyType>(key) BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
@@ -1102,7 +1103,7 @@ class flat_tree
          ? this->priv_insert_unique_prepare(k, data)
          : this->priv_insert_unique_prepare(hint, k, data);
       if(!ret.second){
-         ret.first  = this->nth(data.position - this->cbegin());
+         ret.first  = this->nth(size_type(data.position - this->cbegin()));
          ret.first->second = boost::forward<M>(obj);
       }
       else{
@@ -1234,7 +1235,7 @@ class flat_tree
       size_type count(const key_type& k) const
    {
       std::pair<const_iterator, const_iterator> p = this->equal_range(k);
-      size_type n = p.second - p.first;
+      size_type n = size_type(p.second - p.first);
       return n;
    }
 
@@ -1244,7 +1245,7 @@ class flat_tree
       count(const K& k) const
    {
       std::pair<const_iterator, const_iterator> p = this->equal_range(k);
-      size_type n = p.second - p.first;
+      size_type n = size_type(p.second - p.first);
       return n;
    }
 
@@ -1588,7 +1589,7 @@ class flat_tree
       while (len) {
          size_type step = len >> 1;
          middle = first;
-         middle += step;
+         middle += difference_type(step);
 
          if (key_cmp(key_extract(*middle), key)) {
             first = ++middle;
@@ -1613,7 +1614,7 @@ class flat_tree
       while (len) {
          size_type step = len >> 1;
          middle = first;
-         middle += step;
+         middle += difference_type(step);
 
          if (key_cmp(key, key_extract(*middle))) {
             len = step;
@@ -1638,7 +1639,7 @@ class flat_tree
       while (len) {
          size_type step = len >> 1;
          middle = first;
-         middle += step;
+         middle += difference_type(step);
 
          if (key_cmp(key_extract(*middle), key)){
             first = ++middle;
@@ -1650,7 +1651,7 @@ class flat_tree
          else {
             //Middle is equal to key
             last = first;
-            last += len;
+            last += difference_type(len);
             RanIt const first_ret = this->priv_lower_bound(first, middle, key);
             return std::pair<RanIt, RanIt>
                ( first_ret, this->priv_upper_bound(++middle, last, key));

include/boost/container/detail/iterator.hpp

@@ -30,7 +30,9 @@ namespace container {
 
 using ::boost::intrusive::iterator_traits;
 using ::boost::intrusive::iterator_distance;
+using ::boost::intrusive::iterator_udistance;
 using ::boost::intrusive::iterator_advance;
+using ::boost::intrusive::iterator_uadvance;
 using ::boost::intrusive::iterator;
 using ::boost::intrusive::iterator_enable_if_tag;
 using ::boost::intrusive::iterator_disable_if_tag;

include/boost/container/detail/iterators.hpp

@@ -41,15 +41,15 @@
 namespace boost {
 namespace container {
 
-template <class T, class Difference = std::ptrdiff_t>
+template <class T>
 class constant_iterator
   : public ::boost::container::iterator
-      <std::random_access_iterator_tag, T, Difference, const T*, const T &>
+      <std::random_access_iterator_tag, T, std::ptrdiff_t, const T*, const T &>
 {
-   typedef  constant_iterator<T, Difference> this_type;
+   typedef  constant_iterator<T> this_type;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE explicit constant_iterator(const T &ref, Difference range_size)
+   BOOST_CONTAINER_FORCEINLINE explicit constant_iterator(const T &ref, std::size_t range_size)
       :  m_ptr(&ref), m_num(range_size){}
 
    //Constructors
@@ -94,41 +94,60 @@ class constant_iterator
    BOOST_CONTAINER_FORCEINLINE friend bool operator>= (const constant_iterator& i, const constant_iterator& i2)
    { return !(i < i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend Difference operator- (const constant_iterator& i, const constant_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend std::ptrdiff_t operator- (const constant_iterator& i, const constant_iterator& i2)
    { return i2.distance_to(i); }
 
-   //Arithmetic
+   //Arithmetic signed
-   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator+=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator+=(std::ptrdiff_t off)
    {  this->advance(off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE constant_iterator operator+(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE constant_iterator operator+(std::ptrdiff_t off) const
    {
       constant_iterator other(*this);
       other.advance(off);
       return other;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend constant_iterator operator+(Difference off, const constant_iterator& right)
+   BOOST_CONTAINER_FORCEINLINE friend constant_iterator operator+(std::ptrdiff_t off, const constant_iterator& right)
    {  return right + off; }
 
-   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator-=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator-=(std::ptrdiff_t off)
    {  this->advance(-off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE constant_iterator operator-(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE constant_iterator operator-(std::ptrdiff_t off) const
    {  return *this + (-off);  }
 
-   BOOST_CONTAINER_FORCEINLINE const T& operator*() const
+   BOOST_CONTAINER_FORCEINLINE const T& operator[] (std::ptrdiff_t ) const
    { return dereference(); }
 
-   BOOST_CONTAINER_FORCEINLINE const T& operator[] (Difference ) const
+   BOOST_CONTAINER_FORCEINLINE const T& operator*() const
    { return dereference(); }
 
    BOOST_CONTAINER_FORCEINLINE const T* operator->() const
    { return &(dereference()); }
 
+   //Arithmetic unsigned
+   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator+=(std::size_t off)
+   {  return *this += std::ptrdiff_t(off);  }
+
+   BOOST_CONTAINER_FORCEINLINE constant_iterator operator+(std::size_t off) const
+   {  return *this + std::ptrdiff_t(off);  }
+
+   BOOST_CONTAINER_FORCEINLINE friend constant_iterator operator+(std::size_t off, const constant_iterator& right)
+   {  return std::ptrdiff_t(off) + right;  }
+
+   BOOST_CONTAINER_FORCEINLINE constant_iterator& operator-=(std::size_t off)
+   {  return *this -= std::ptrdiff_t(off);  }
+
+   BOOST_CONTAINER_FORCEINLINE constant_iterator operator-(std::size_t off) const
+   {  return *this - std::ptrdiff_t(off);  }
+
+   BOOST_CONTAINER_FORCEINLINE const T& operator[] (std::size_t off) const
+   { return (*this)[std::ptrdiff_t(off)]; }
+
    private:
    const T *   m_ptr;
-   Difference  m_num;
+   std::size_t m_num;
 
    BOOST_CONTAINER_FORCEINLINE void increment()
    { --m_num; }
@@ -145,22 +164,22 @@ class constant_iterator
    BOOST_CONTAINER_FORCEINLINE const T & dereference() const
    { return *m_ptr; }
 
-   BOOST_CONTAINER_FORCEINLINE void advance(Difference n)
+   BOOST_CONTAINER_FORCEINLINE void advance(std::ptrdiff_t n)
-   {  m_num -= n; }
+   {  m_num = std::size_t(std::ptrdiff_t(m_num) - n); }
 
-   BOOST_CONTAINER_FORCEINLINE Difference distance_to(const this_type &other)const
+   BOOST_CONTAINER_FORCEINLINE std::ptrdiff_t distance_to(const this_type &other)const
-   {  return m_num - other.m_num;   }
+   {  return std::ptrdiff_t(m_num - other.m_num);   }
 };
 
-template <class T, class Difference>
+template <class T>
 class value_init_construct_iterator
   : public ::boost::container::iterator
-      <std::random_access_iterator_tag, T, Difference, const T*, const T &>
+      <std::random_access_iterator_tag, T, std::ptrdiff_t, const T*, const T &>
 {
-   typedef  value_init_construct_iterator<T, Difference> this_type;
+   typedef  value_init_construct_iterator<T> this_type;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE explicit value_init_construct_iterator(Difference range_size)
+   BOOST_CONTAINER_FORCEINLINE explicit value_init_construct_iterator(std::size_t range_size)
       :  m_num(range_size){}
 
    //Constructors
@@ -205,27 +224,27 @@ class value_init_construct_iterator
    BOOST_CONTAINER_FORCEINLINE friend bool operator>= (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return !(i < i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend Difference operator- (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend std::ptrdiff_t operator- (const value_init_construct_iterator& i, const value_init_construct_iterator& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
-   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator& operator+=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator& operator+=(std::ptrdiff_t off)
    {  this->advance(off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator operator+(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator operator+(std::ptrdiff_t off) const
    {
       value_init_construct_iterator other(*this);
       other.advance(off);
       return other;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend value_init_construct_iterator operator+(Difference off, const value_init_construct_iterator& right)
+   BOOST_CONTAINER_FORCEINLINE friend value_init_construct_iterator operator+(std::ptrdiff_t off, const value_init_construct_iterator& right)
    {  return right + off; }
 
-   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator& operator-=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator& operator-=(std::ptrdiff_t off)
    {  this->advance(-off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator operator-(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE value_init_construct_iterator operator-(std::ptrdiff_t off) const
    {  return *this + (-off);  }
 
    //This pseudo-iterator's dereference operations have no sense since value is not
@@ -236,7 +255,7 @@ class value_init_construct_iterator
    //const T* operator->() const;
 
    private:
-   Difference  m_num;
+   std::size_t  m_num;
 
    BOOST_CONTAINER_FORCEINLINE void increment()
    { --m_num; }
@@ -256,22 +275,22 @@ class value_init_construct_iterator
       return dummy;
    }
 
-   BOOST_CONTAINER_FORCEINLINE void advance(Difference n)
+   BOOST_CONTAINER_FORCEINLINE void advance(std::ptrdiff_t n)
-   {  m_num -= n; }
+   {  m_num = std::size_t(std::ptrdiff_t(m_num) - n); }
 
-   BOOST_CONTAINER_FORCEINLINE Difference distance_to(const this_type &other)const
+   BOOST_CONTAINER_FORCEINLINE std::ptrdiff_t distance_to(const this_type &other)const
-   {  return m_num - other.m_num;   }
+   {  return std::ptrdiff_t(m_num - other.m_num);   }
 };
 
-template <class T, class Difference>
+template <class T>
 class default_init_construct_iterator
   : public ::boost::container::iterator
-      <std::random_access_iterator_tag, T, Difference, const T*, const T &>
+      <std::random_access_iterator_tag, T, std::ptrdiff_t, const T*, const T &>
 {
-   typedef  default_init_construct_iterator<T, Difference> this_type;
+   typedef  default_init_construct_iterator<T> this_type;
 
    public:
-   BOOST_CONTAINER_FORCEINLINE explicit default_init_construct_iterator(Difference range_size)
+   BOOST_CONTAINER_FORCEINLINE explicit default_init_construct_iterator(std::size_t range_size)
       :  m_num(range_size){}
 
    //Constructors
@@ -316,27 +335,27 @@ class default_init_construct_iterator
    BOOST_CONTAINER_FORCEINLINE friend bool operator>= (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return !(i < i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend Difference operator- (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
+   BOOST_CONTAINER_FORCEINLINE friend std::ptrdiff_t operator- (const default_init_construct_iterator& i, const default_init_construct_iterator& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
-   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator& operator+=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator& operator+=(std::ptrdiff_t off)
    {  this->advance(off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator operator+(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator operator+(std::ptrdiff_t off) const
    {
       default_init_construct_iterator other(*this);
       other.advance(off);
       return other;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend default_init_construct_iterator operator+(Difference off, const default_init_construct_iterator& right)
+   BOOST_CONTAINER_FORCEINLINE friend default_init_construct_iterator operator+(std::ptrdiff_t off, const default_init_construct_iterator& right)
    {  return right + off; }
 
-   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator& operator-=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator& operator-=(std::ptrdiff_t off)
    {  this->advance(-off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator operator-(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE default_init_construct_iterator operator-(std::ptrdiff_t off) const
    {  return *this + (-off);  }
 
    //This pseudo-iterator's dereference operations have no sense since value is not
@@ -347,7 +366,7 @@ class default_init_construct_iterator
    //const T* operator->() const;
 
    private:
-   Difference  m_num;
+   std::size_t  m_num;
 
    BOOST_CONTAINER_FORCEINLINE void increment()
    { --m_num; }
@@ -367,22 +386,22 @@ class default_init_construct_iterator
       return dummy;
    }
 
-   BOOST_CONTAINER_FORCEINLINE void advance(Difference n)
+   BOOST_CONTAINER_FORCEINLINE void advance(std::ptrdiff_t n)
-   {  m_num -= n; }
+   {  m_num = std::size_t(std::ptrdiff_t(m_num) - n); }
 
-   BOOST_CONTAINER_FORCEINLINE Difference distance_to(const this_type &other) const
+   BOOST_CONTAINER_FORCEINLINE std::ptrdiff_t distance_to(const this_type &other) const
-   {  return m_num - other.m_num;   }
+   {  return std::ptrdiff_t(m_num - other.m_num);   }
 };
 
 
-template <class T, class Difference = std::ptrdiff_t>
+template <class T>
 class repeat_iterator
   : public ::boost::container::iterator
-      <std::random_access_iterator_tag, T, Difference, T*, T&>
+      <std::random_access_iterator_tag, T, std::ptrdiff_t, T*, T&>
 {
-   typedef repeat_iterator<T, Difference> this_type;
+   typedef repeat_iterator<T> this_type;
    public:
-   BOOST_CONTAINER_FORCEINLINE explicit repeat_iterator(T &ref, Difference range_size)
+   BOOST_CONTAINER_FORCEINLINE explicit repeat_iterator(T &ref, std::size_t range_size)
       :  m_ptr(&ref), m_num(range_size){}
 
    //Constructors
@@ -427,33 +446,33 @@ class repeat_iterator
    BOOST_CONTAINER_FORCEINLINE friend bool operator>= (const this_type& i, const this_type& i2)
    { return !(i < i2); }
 
-   BOOST_CONTAINER_FORCEINLINE friend Difference operator- (const this_type& i, const this_type& i2)
+   BOOST_CONTAINER_FORCEINLINE friend std::ptrdiff_t operator- (const this_type& i, const this_type& i2)
    { return i2.distance_to(i); }
 
    //Arithmetic
-   BOOST_CONTAINER_FORCEINLINE this_type& operator+=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE this_type& operator+=(std::ptrdiff_t off)
    {  this->advance(off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE this_type operator+(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE this_type operator+(std::ptrdiff_t off) const
    {
       this_type other(*this);
       other.advance(off);
       return other;
    }
 
-   BOOST_CONTAINER_FORCEINLINE friend this_type operator+(Difference off, const this_type& right)
+   BOOST_CONTAINER_FORCEINLINE friend this_type operator+(std::ptrdiff_t off, const this_type& right)
    {  return right + off; }
 
-   BOOST_CONTAINER_FORCEINLINE this_type& operator-=(Difference off)
+   BOOST_CONTAINER_FORCEINLINE this_type& operator-=(std::ptrdiff_t off)
    {  this->advance(-off); return *this;   }
 
-   BOOST_CONTAINER_FORCEINLINE this_type operator-(Difference off) const
+   BOOST_CONTAINER_FORCEINLINE this_type operator-(std::ptrdiff_t off) const
    {  return *this + (-off);  }
 
    BOOST_CONTAINER_FORCEINLINE T& operator*() const
    { return dereference(); }
 
-   BOOST_CONTAINER_FORCEINLINE T& operator[] (Difference ) const
+   BOOST_CONTAINER_FORCEINLINE T& operator[] (std::ptrdiff_t ) const
    { return dereference(); }
 
    BOOST_CONTAINER_FORCEINLINE T *operator->() const
@@ -461,7 +480,7 @@ class repeat_iterator
 
    private:
    T *         m_ptr;
-   Difference  m_num;
+   std::size_t m_num;
 
    BOOST_CONTAINER_FORCEINLINE void increment()
    { --m_num; }
@@ -478,22 +497,22 @@ class repeat_iterator
    BOOST_CONTAINER_FORCEINLINE T & dereference() const
    { return *m_ptr; }
 
-   BOOST_CONTAINER_FORCEINLINE void advance(Difference n)
+   BOOST_CONTAINER_FORCEINLINE void advance(std::ptrdiff_t n)
-   {  m_num -= n; }
+   {  m_num = std::size_t(std::ptrdiff_t(m_num - n)); }
 
-   BOOST_CONTAINER_FORCEINLINE Difference distance_to(const this_type &other)const
+   BOOST_CONTAINER_FORCEINLINE std::ptrdiff_t distance_to(const this_type &other)const
-   {  return m_num - other.m_num;   }
+   {  return std::ptrdiff_t(m_num - other.m_num);   }
 };
 
-template <class T, class EmplaceFunctor, class Difference /*= std::ptrdiff_t*/>
+template <class T, class EmplaceFunctor>
 class emplace_iterator
   : public ::boost::container::iterator
-      <std::random_access_iterator_tag, T, Difference, const T*, const T &>
+      <std::random_access_iterator_tag, T, std::ptrdiff_t, const T*, const T &>
 {
    typedef emplace_iterator this_type;
 
    public:
-   typedef Difference difference_type;
+   typedef std::ptrdiff_t difference_type;
    BOOST_CONTAINER_FORCEINLINE explicit emplace_iterator(EmplaceFunctor&e)
       :  m_num(1), m_pe(&e){}
 
@@ -579,7 +598,7 @@ class emplace_iterator
    {  (*m_pe)(dest);  }
 
    private:
-   difference_type m_num;
+   std::size_t m_num;
    EmplaceFunctor *            m_pe;
 
    BOOST_CONTAINER_FORCEINLINE void increment()

include/boost/container/detail/multiallocation_chain.hpp

@@ -153,8 +153,8 @@ class basic_multiallocation_chain
       char_ptr elem = char_pointer_traits::static_cast_from(b);
       if(num_units){
          char_ptr prev_elem = elem;
-         elem += unit_bytes;
+         elem += difference_type(unit_bytes);
-         for(size_type i = 0; i != num_units-1; ++i, elem += unit_bytes){
+         for(size_type i = 0; i != num_units-1u; ++i, elem += difference_type(unit_bytes)){
             ::new (boost::movelib::to_raw_pointer(prev_elem), boost_container_new_t()) void_pointer(elem);
             prev_elem = elem;
          }

include/boost/container/detail/next_capacity.hpp

@@ -48,13 +48,13 @@ struct grow_factor_ratio
       SizeType new_cap = 0;
 
       if(cur_cap <= overflow_limit){
-         new_cap = cur_cap * Numerator / Denominator;
+         new_cap = SizeType(cur_cap * Numerator / Denominator);
       }
       else if(Denominator == 1 || (SizeType(new_cap = cur_cap) / Denominator) > overflow_limit){
          new_cap = (SizeType)-1;
       }
       else{
-         new_cap *= Numerator;
+         new_cap = SizeType(new_cap*Numerator);
       }
       return max_value<SizeType>
                ( SizeType(Minimum)

include/boost/container/detail/node_alloc_holder.hpp

@@ -329,7 +329,7 @@ struct node_alloc_holder
 
    template<class FwdIterator, class Inserter>
    void allocate_many_and_construct
-      (FwdIterator beg, difference_type n, Inserter inserter)
+      (FwdIterator beg, size_type n, Inserter inserter)
    {
       if(n){
          typedef typename node_allocator_version_traits_type::multiallocation_chain multiallocation_chain_t;

include/boost/container/detail/tree.hpp

@@ -711,7 +711,7 @@ class tree
    {
       //Optimized allocation and construction
       this->allocate_many_and_construct
-         ( first, boost::container::iterator_distance(first, last)
+         ( first, boost::container::iterator_udistance(first, last)
          , insert_equal_end_hint_functor<Node, Icont>(this->icont()));
    }
 
@@ -728,7 +728,7 @@ class tree
    {
       //Optimized allocation and construction
       this->allocate_many_and_construct
-         ( first, boost::container::iterator_distance(first, last)
+         ( first, boost::container::iterator_udistance(first, last)
          , dtl::push_back_functor<Node, Icont>(this->icont()));
       //AllocHolder clears in case of exception
    }

include/boost/container/devector.hpp

@@ -179,7 +179,7 @@ class devector
    typedef typename detail::allocation_guard<allocator_type> allocation_guard;
 
    // Random access pseudo iterator always yielding to the same result
-   typedef constant_iterator<T, difference_type> cvalue_iterator;
+   typedef constant_iterator<T> cvalue_iterator;
 
    #endif // ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
 
@@ -348,7 +348,7 @@ class devector
       )
       : m_(allocator, pointer(), 0u, 0u, 0u)
    {
-      const size_type n = boost::container::iterator_distance(first, last);
+      const size_type n = boost::container::iterator_udistance(first, last);
       m_.buffer = n ? allocate(n) : pointer();
       m_.front_idx = 0u;
       //this->allocate(n) will take care of overflows
@@ -703,7 +703,7 @@ class devector
          >::type * = 0)
       )
    {
-      const size_type n = boost::container::iterator_distance(first, last);
+      const size_type n = boost::container::iterator_udistance(first, last);
 
       if (capacity() >= n)
       {
@@ -943,7 +943,7 @@ class devector
   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
    size_type size() const BOOST_NOEXCEPT
   {
-    return m_.back_idx - m_.front_idx;
+    return size_type(m_.back_idx - m_.front_idx);
   }
 
   /**
@@ -991,7 +991,7 @@ class devector
   BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
    size_type back_free_capacity() const BOOST_NOEXCEPT
   {
-    return m_.capacity - m_.back_idx;
+    return size_type(m_.capacity - m_.back_idx);
   }
 
   /** **Equivalent to**: `resize_back(sz)` */
@@ -1643,7 +1643,7 @@ class devector
       }
       else
       {
-         size_type new_elem_index = position - begin();
+         size_type new_elem_index = size_type(position - begin());
          return this->emplace_slow_path(new_elem_index, boost::forward<Args>(args)...);
       }
    }
@@ -1668,7 +1668,7 @@ class devector
          return begin();\
       }\
       else{\
-         size_type new_elem_index = position - begin();\
+         size_type new_elem_index = size_type(position - begin());\
          return this->emplace_slow_path(new_elem_index BOOST_MOVE_I##N BOOST_MOVE_FWD##N);\
       }\
    }\
@@ -1900,9 +1900,9 @@ class devector
    */
    iterator erase(iterator first, iterator last)
    {
-      size_type front_distance = last - begin();
+      size_type front_distance = size_type(last - begin());
-      size_type back_distance = end() - first;
+      size_type back_distance  = size_type(end() - first);
-      size_type n = boost::container::iterator_distance(first, last);
+      size_type n = boost::container::iterator_udistance(first, last);
 
       if (front_distance < back_distance)
       {
@@ -2152,7 +2152,7 @@ class devector
 
    BOOST_CONTAINER_FORCEINLINE size_type back_capacity() const
    {
-      return m_.capacity - m_.front_idx;
+      return size_type(m_.capacity - m_.front_idx);
    }
 
    size_type calculate_new_capacity(size_type requested_capacity)
@@ -2671,7 +2671,7 @@ class devector
       m_.buffer = new_buffer;
       //Safe cast, allocate() will handle stored_size_type overflow
       m_.set_capacity(new_capacity);
-      m_.set_back_idx(m_.back_idx - m_.front_idx + buffer_offset);
+      m_.set_back_idx(size_type(m_.back_idx - m_.front_idx) + buffer_offset);
       m_.set_front_idx(buffer_offset);
 
       BOOST_ASSERT(invariants_ok());
@@ -2680,7 +2680,7 @@ class devector
    template <typename ForwardIterator>
    iterator insert_range(const_iterator position, ForwardIterator first, ForwardIterator last)
    {
-      size_type n = boost::container::iterator_distance(first, last);
+      size_type n = boost::container::iterator_udistance(first, last);
 
       if (position == end() && back_free_capacity() >= n) {// fast path
          iterator r(this->end());
@@ -2701,8 +2701,8 @@ class devector
    template <typename ForwardIterator>
    iterator insert_range_slow_path(const_iterator position, ForwardIterator first, ForwardIterator last)
    {
-      size_type n = boost::container::iterator_distance(first, last);
+      size_type n = boost::container::iterator_udistance(first, last);
-      size_type index = position - begin();
+      size_type index = size_type(position - begin());
 
       if (front_free_capacity() + back_free_capacity() >= n) {
          // if we move enough, it can be done without reallocation
@@ -2834,7 +2834,7 @@ class devector
    template <typename ForwardIterator>
    void allocate_and_copy_range(ForwardIterator first, ForwardIterator last)
    {
-      size_type n = boost::container::iterator_distance(first, last);
+      size_type n = boost::container::iterator_udistance(first, last);
 
       pointer new_buffer = n ? allocate(n) : pointer();
       allocation_guard new_buffer_guard(new_buffer, n, get_allocator_ref());
@@ -2861,7 +2861,7 @@ class devector
    template <typename ForwardIterator>
    void overwrite_buffer_impl(ForwardIterator first, ForwardIterator last, dtl::true_)
    {
-      const size_type n = boost::container::iterator_distance(first, last);
+      const size_type n = boost::container::iterator_udistance(first, last);
 
       BOOST_ASSERT(capacity() >= n);
       boost::container::uninitialized_copy_alloc_n
@@ -2901,7 +2901,7 @@ class devector
       back_guard.release();
 
       m_.front_idx = 0;
-      m_.set_back_idx(pos - begin());
+      m_.set_back_idx(size_type(pos - begin()));
       return first;
    }
 

include/boost/container/list.hpp

@@ -444,7 +444,7 @@ class list
    //! <b>Complexity</b>: Linear to n.
    BOOST_CONTAINER_FORCEINLINE void assign(size_type n, const T& val)
    {
-      typedef constant_iterator<value_type, difference_type> cvalue_iterator;
+      typedef constant_iterator<value_type> cvalue_iterator;
       return this->assign(cvalue_iterator(val, n), cvalue_iterator());
    }
 
@@ -676,7 +676,7 @@ class list
    void resize(size_type new_size)
    {
       if(!priv_try_shrink(new_size)){
-         typedef value_init_construct_iterator<value_type, difference_type> value_init_iterator;
+         typedef value_init_construct_iterator<value_type> value_init_iterator;
          this->insert(this->cend(), value_init_iterator(new_size - this->size()), value_init_iterator());
       }
    }
@@ -911,7 +911,7 @@ class list
    iterator insert(const_iterator position, size_type n, const T& x)
    {
       //range check is done by insert
-      typedef constant_iterator<value_type, difference_type> cvalue_iterator;
+      typedef constant_iterator<value_type> cvalue_iterator;
       return this->insert(position, cvalue_iterator(x, n), cvalue_iterator());
    }
 
@@ -966,7 +966,7 @@ class list
       insertion_functor func(this->icont(), position.get());
       iterator before_p(position.get());
       --before_p;
-      this->allocate_many_and_construct(first, boost::container::iterator_distance(first, last), func);
+      this->allocate_many_and_construct(first, boost::container::iterator_udistance(first, last), func);
       return ++before_p;
    }
    #endif

include/boost/container/slist.hpp

@@ -471,7 +471,7 @@ class slist
    //! <b>Complexity</b>: Linear to n.
    void assign(size_type n, const T& val)
    {
-      typedef constant_iterator<value_type, difference_type> cvalue_iterator;
+      typedef constant_iterator<value_type> cvalue_iterator;
       return this->assign(cvalue_iterator(val, n), cvalue_iterator());
    }
 
@@ -709,7 +709,7 @@ class slist
    {
       const_iterator last_pos;
       if(!priv_try_shrink(new_size, last_pos)){
-         typedef value_init_construct_iterator<value_type, difference_type> value_init_iterator;
+         typedef value_init_construct_iterator<value_type> value_init_iterator;
          this->insert_after(last_pos, value_init_iterator(new_size - this->size()), value_init_iterator());
       }
    }
@@ -887,7 +887,7 @@ class slist
    //!   previous values.
    iterator insert_after(const_iterator prev_p, size_type n, const value_type& x)
    {
-      typedef constant_iterator<value_type, difference_type> cvalue_iterator;
+      typedef constant_iterator<value_type> cvalue_iterator;
       return this->insert_after(prev_p, cvalue_iterator(x, n), cvalue_iterator());
    }
 
@@ -955,7 +955,7 @@ class slist
    {
       //Optimized allocation and construction
       insertion_functor func(this->icont(), prev.get());
-      this->allocate_many_and_construct(first, boost::container::iterator_distance(first, last), func);
+      this->allocate_many_and_construct(first, boost::container::iterator_udistance(first, last), func);
       return iterator(func.inserted_first());
    }
    #endif

include/boost/container/stable_vector.hpp

@@ -289,6 +289,7 @@ class stable_vector_iterator
    typedef std::random_access_iterator_tag                                          iterator_category;
    typedef typename non_const_ptr_traits::element_type                              value_type;
    typedef typename non_const_ptr_traits::difference_type                           difference_type;
+   typedef typename non_const_ptr_traits::size_type                                 size_type;
    typedef typename ::boost::container::dtl::if_c
       < IsConst
       , typename non_const_ptr_traits::template
@@ -383,6 +384,7 @@ class stable_vector_iterator
       reference operator[](difference_type off) const BOOST_NOEXCEPT_OR_NOTHROW
    {  return node_ptr_traits::static_cast_from(this->m_pn->up[off])->get_data();  }
 
+   //Arithmetic
    BOOST_CONTAINER_FORCEINLINE stable_vector_iterator& operator+=(difference_type off) BOOST_NOEXCEPT_OR_NOTHROW
    {
       if(off) this->m_pn = this->m_pn->up[off];
@@ -416,6 +418,7 @@ class stable_vector_iterator
       return tmp;
    }
 
+   //Difference
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
       friend difference_type operator-(const stable_vector_iterator &left, const stable_vector_iterator &right) BOOST_NOEXCEPT_OR_NOTHROW
    {  return left.m_pn->up - right.m_pn->up;  }
@@ -916,7 +919,7 @@ class stable_vector
    //! <b>Complexity</b>: Linear to n.
    BOOST_CONTAINER_FORCEINLINE void assign(size_type n, const T& t)
    {
-      typedef constant_iterator<value_type, difference_type> cvalue_iterator;
+      typedef constant_iterator<value_type> cvalue_iterator;
       this->assign(cvalue_iterator(t, n), cvalue_iterator());
    }
 
@@ -1155,12 +1158,13 @@ class stable_vector
    //! <b>Complexity</b>: Linear to the difference between size() and new_size.
    void resize(size_type n)
    {
-      typedef value_init_construct_iterator<value_type, difference_type> value_init_iterator;
+      typedef value_init_construct_iterator<value_type> value_init_iterator;
       BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
       if(n > this->size())
-         this->insert(this->cend(), value_init_iterator(n - this->size()), value_init_iterator());
+         this->insert( this->cend()
+                     , value_init_iterator(n - this->size()), value_init_iterator());
       else if(n < this->size())
-         this->erase(this->cbegin() + n, this->cend());
+         this->erase(this->cbegin() + difference_type(n), this->cend());
    }
 
    //! <b>Effects</b>: Inserts or erases elements at the end such that
@@ -1173,12 +1177,12 @@ class stable_vector
    //! <b>Note</b>: Non-standard extension
    void resize(size_type n, default_init_t)
    {
-      typedef default_init_construct_iterator<value_type, difference_type> default_init_iterator;
+      typedef default_init_construct_iterator<value_type> default_init_iterator;
       BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
       if(n > this->size())
          this->insert(this->cend(), default_init_iterator(n - this->size()), default_init_iterator());
       else if(n < this->size())
-         this->erase(this->cbegin() + n, this->cend());
+         this->erase(this->cbegin() + difference_type(n), this->cend());
    }
 
    //! <b>Effects</b>: Inserts or erases elements at the end such that
@@ -1193,7 +1197,7 @@ class stable_vector
       if(n > this->size())
          this->insert(this->cend(), n - this->size(), t);
       else if(n < this->size())
-         this->erase(this->cbegin() + n, this->cend());
+         this->erase(this->cbegin() + difference_type(n), this->cend());
    }
 
    //! <b>Effects</b>: Number of elements for which memory has been allocated.
@@ -1490,7 +1494,7 @@ class stable_vector
    reference emplace_back(Args &&...args)
    {
       typedef emplace_functor<Args...>         EmplaceFunctor;
-      typedef emplace_iterator<value_type, EmplaceFunctor, difference_type> EmplaceIterator;
+      typedef emplace_iterator<value_type, EmplaceFunctor> EmplaceIterator;
       EmplaceFunctor &&ef = EmplaceFunctor(boost::forward<Args>(args)...);
       return *this->insert(this->cend(), EmplaceIterator(ef), EmplaceIterator());
    }
@@ -1508,9 +1512,9 @@ class stable_vector
    iterator emplace(const_iterator p, Args && ...args)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
-      size_type pos_n = p - cbegin();
+      difference_type pos_n = p - cbegin();
       typedef emplace_functor<Args...>         EmplaceFunctor;
-      typedef emplace_iterator<value_type, EmplaceFunctor, difference_type> EmplaceIterator;
+      typedef emplace_iterator<value_type, EmplaceFunctor> EmplaceIterator;
       EmplaceFunctor &&ef = EmplaceFunctor(boost::forward<Args>(args)...);
       this->insert(p, EmplaceIterator(ef), EmplaceIterator());
       return iterator(this->begin() + pos_n);
@@ -1524,7 +1528,7 @@ class stable_vector
    {\
       typedef emplace_functor##N\
          BOOST_MOVE_LT##N BOOST_MOVE_TARG##N BOOST_MOVE_GT##N EmplaceFunctor;\
-      typedef emplace_iterator<value_type, EmplaceFunctor, difference_type>  EmplaceIterator;\
+      typedef emplace_iterator<value_type, EmplaceFunctor>  EmplaceIterator;\
       EmplaceFunctor ef BOOST_MOVE_LP##N BOOST_MOVE_FWD##N BOOST_MOVE_RP##N;\
       return *this->insert(this->cend() , EmplaceIterator(ef), EmplaceIterator());\
    }\
@@ -1535,11 +1539,11 @@ class stable_vector
       BOOST_ASSERT(this->priv_in_range_or_end(p));\
       typedef emplace_functor##N\
          BOOST_MOVE_LT##N BOOST_MOVE_TARG##N BOOST_MOVE_GT##N EmplaceFunctor;\
-      typedef emplace_iterator<value_type, EmplaceFunctor, difference_type>  EmplaceIterator;\
+      typedef emplace_iterator<value_type, EmplaceFunctor>  EmplaceIterator;\
       EmplaceFunctor ef BOOST_MOVE_LP##N BOOST_MOVE_FWD##N BOOST_MOVE_RP##N;\
-      const size_type pos_n = p - this->cbegin();\
+      const size_type pos_n = size_type(p - this->cbegin());\
       this->insert(p, EmplaceIterator(ef), EmplaceIterator());\
-      return this->begin() += pos_n;\
+      return this->begin() += difference_type(pos_n);\
    }\
    //
    BOOST_MOVE_ITERATE_0TO9(BOOST_CONTAINER_STABLE_VECTOR_EMPLACE_CODE)
@@ -1608,7 +1612,7 @@ class stable_vector
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
       BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
-      typedef constant_iterator<value_type, difference_type> cvalue_iterator;
+      typedef constant_iterator<value_type> cvalue_iterator;
       return this->insert(p, cvalue_iterator(t, n), cvalue_iterator());
    }
 
@@ -1654,11 +1658,11 @@ class stable_vector
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
       BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
-      const size_type pos_n = p - this->cbegin();
+      const difference_type pos_n = p - this->cbegin();
       for(; first != last; ++first){
          this->emplace(p, *first);
       }
-      return this->begin() + pos_n;
+      return this->begin() + difference_type(pos_n);
    }
 
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -1671,7 +1675,7 @@ class stable_vector
       insert(const_iterator p, FwdIt first, FwdIt last)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
-      const size_type num_new = static_cast<size_type>(boost::container::iterator_distance(first, last));
+      const size_type num_new = boost::container::iterator_udistance(first, last);
       const size_type idx     = static_cast<size_type>(p - this->cbegin());
       if(num_new){
          //Fills the node pool and inserts num_new null pointers in idx.
@@ -1679,7 +1683,7 @@ class stable_vector
          //past-new nodes are not aligned until the end of this function
          //or in a rollback in case of exception
          index_iterator it_past_newly_constructed(this->priv_insert_forward_non_templated(idx, num_new));
-         const index_iterator it_past_new(it_past_newly_constructed + num_new);
+         const index_iterator it_past_new(it_past_newly_constructed + difference_type(num_new));
          {
             //Prepare rollback
             insert_rollback rollback(*this, it_past_newly_constructed, it_past_new);
@@ -1699,7 +1703,7 @@ class stable_vector
          //nodes before insertion p in priv_insert_forward_non_templated(...)
          index_traits_type::fix_up_pointers_from(this->index, it_past_newly_constructed);
       }
-      return this->begin() + idx;
+      return this->begin() + static_cast<difference_type>(idx);
    }
    #endif
 
@@ -1724,7 +1728,7 @@ class stable_vector
    {
       BOOST_ASSERT(this->priv_in_range(p));
       BOOST_CONTAINER_STABLE_VECTOR_CHECK_INVARIANT;
-      const size_type d = p - this->cbegin();
+      const difference_type d = p - this->cbegin();
       index_iterator it = this->index.begin() + d;
       this->priv_delete_node(p.node_pointer());
       it = this->index.erase(it);
@@ -1749,10 +1753,11 @@ class stable_vector
       size_type d_dif = d2 - d1;
       if(d_dif){
          multiallocation_chain holder;
-         const index_iterator it1(this->index.begin() + d1);
+         const index_iterator it1(this->index.begin() + difference_type(d1));
-         const index_iterator it2(it1 + d_dif);
+         const index_iterator it2(it1 + difference_type(d_dif));
          index_iterator it(it1);
-         while(d_dif--){
+         while(d_dif){
+            --d_dif;
             node_base_ptr &nb = *it;
             ++it;
             node_type &n = *node_ptr_traits::static_cast_from(nb);
@@ -1861,7 +1866,7 @@ class stable_vector
       //Check range
       BOOST_ASSERT(this->index.empty() || (this->index.data() <= p->up));
       BOOST_ASSERT(this->index.empty() || p->up <= (this->index.data() + this->index.size()));
-      return this->index.empty() ? 0 : p->up - this->index.data();
+      return this->index.empty() ? 0u : size_type(p->up - this->index.data());
    }
 
    class insert_rollback
@@ -1920,15 +1925,15 @@ class stable_vector
 
       //Now try to make room in the vector
       const node_base_ptr_ptr old_buffer = this->index.data();
-      this->index.insert(this->index.begin() + idx, num_new, node_ptr());
+      this->index.insert(this->index.begin() + (difference_type)idx, num_new, node_ptr());
       bool new_buffer = this->index.data() != old_buffer;
 
       //Fix the pointers for the newly allocated buffer
       const index_iterator index_beg = this->index.begin();
       if(new_buffer){
-         index_traits_type::fix_up_pointers(index_beg, index_beg + idx);
+         index_traits_type::fix_up_pointers(index_beg, index_beg + (difference_type)idx);
       }
-      return index_beg + idx;
+      return index_beg + (difference_type)idx;
    }
 
    BOOST_CONTAINER_FORCEINLINE bool priv_capacity_bigger_than_size() const
@@ -1962,14 +1967,14 @@ class stable_vector
    iterator priv_insert(const_iterator p, const value_type &t)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
-      typedef constant_iterator<value_type, difference_type> cvalue_iterator;
+      typedef constant_iterator<value_type> cvalue_iterator;
       return this->insert(p, cvalue_iterator(t, 1), cvalue_iterator());
    }
 
    iterator priv_insert(const_iterator p, BOOST_RV_REF(T) x)
    {
       BOOST_ASSERT(this->priv_in_range_or_end(p));
-      typedef repeat_iterator<T, difference_type>  repeat_it;
+      typedef repeat_iterator<T>  repeat_it;
       typedef boost::move_iterator<repeat_it>      repeat_move_it;
       //Just call more general insert(p, size, value) and return iterator
       return this->insert(p, repeat_move_it(repeat_it(x, 1)), repeat_move_it(repeat_it()));

include/boost/container/string.hpp

@@ -88,11 +88,13 @@ class basic_string_base
 
    typedef Allocator allocator_type;
  public:
-   typedef allocator_traits<allocator_type> allocator_traits_type;
+   typedef allocator_traits<allocator_type>                 allocator_traits_type;
-   typedef allocator_type                              stored_allocator_type;
+   typedef allocator_type                                   stored_allocator_type;
-   typedef typename allocator_traits_type::pointer     pointer;
+   typedef typename allocator_traits_type::pointer          pointer;
-   typedef typename allocator_traits_type::value_type  value_type;
+   typedef typename allocator_traits_type::value_type       value_type;
-   typedef typename allocator_traits_type::size_type   size_type;
+   typedef typename allocator_traits_type::size_type        size_type;
+   typedef typename allocator_traits_type::difference_type  difference_type;
+
    typedef ::boost::intrusive::pointer_traits<pointer> pointer_traits;
 
    BOOST_CONTAINER_FORCEINLINE basic_string_base()
@@ -414,8 +416,8 @@ class basic_string_base
    BOOST_CONTAINER_FORCEINLINE pointer priv_end_addr() const
    {
       return this->is_short()
-         ? this->priv_short_addr() + this->priv_short_size()
+         ? this->priv_short_addr() + difference_type(this->priv_short_size())
-         : this->priv_long_addr()  + this->priv_long_size()
+         : this->priv_long_addr()  + difference_type(this->priv_long_size())
          ;
    }
 
@@ -460,11 +462,21 @@ class basic_string_base
    }
 
    BOOST_CONTAINER_FORCEINLINE void priv_short_size(size_type sz)
-   {  this->members_.pshort_repr()->h.length = (unsigned char)sz; }
+   {
+      typedef unsigned char uchar_type;
+      static const uchar_type mask = uchar_type(uchar_type(-1) >> 1U);
+      BOOST_ASSERT( sz <= mask );
+      //Make -Wconversion happy
+      this->members_.pshort_repr()->h.length = uchar_type(uchar_type(sz) & mask);
+   }
 
    BOOST_CONTAINER_FORCEINLINE void priv_long_size(size_type sz)
-   {  this->members_.plong_repr()->length = sz;  }
+   {
-
+      static const size_type mask = size_type(-1) >> 1U;
+      BOOST_ASSERT( sz <= mask );
+      //Make -Wconversion happy
+      this->members_.plong_repr()->length = sz & mask;
+   }
    #if defined(BOOST_GCC) && (BOOST_GCC >= 40700)
    #pragma GCC diagnostic pop
    #endif
@@ -611,7 +623,7 @@ class basic_string
 
    #ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
    private:
-   typedef constant_iterator<CharT, difference_type> cvalue_iterator;
+   typedef constant_iterator<CharT> cvalue_iterator;
    typedef typename base_t::alloc_version  alloc_version;
    typedef ::boost::intrusive::pointer_traits<pointer> pointer_traits;
    #endif   //#ifndef BOOST_CONTAINER_DOXYGEN_INVOKED
@@ -751,7 +763,7 @@ class basic_string
       : base_t()
    {
       this->priv_terminate_string();
-      this->assign(s, s + n);
+      this->assign(s, s + difference_type(n));
    }
 
    //! <b>Effects</b>: Constructs a basic_string taking the allocator as parameter,
@@ -760,7 +772,7 @@ class basic_string
       : base_t(a)
    {
       this->priv_terminate_string();
-      this->assign(s, s + n);
+      this->assign(s, s + difference_type(n));
    }
 
    //! <b>Effects</b>: Constructs a basic_string with a default-constructed allocator,
@@ -1147,7 +1159,7 @@ class basic_string
    void resize(size_type n, CharT c)
    {
       if (n <= this->size())
-         this->erase(this->begin() + n, this->end());
+         this->erase(this->begin() + difference_type(n), this->end());
       else
          this->append(n - this->size(), c);
    }
@@ -1172,7 +1184,7 @@ class basic_string
    void resize(size_type n, default_init_t)
    {
       if (n <= this->size())
-         this->erase(this->begin() + n, this->end());
+         this->erase(this->begin() + difference_type(n), this->end());
       else{
          this->priv_reserve(n, false);
          this->priv_size(n);
@@ -1310,7 +1322,7 @@ class basic_string
       reference operator[](size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->size() > n);
-      return *(this->priv_addr() + n);
+      return *(this->priv_addr() + difference_type(n));
    }
 
    //! <b>Requires</b>: size() > n.
@@ -1325,7 +1337,7 @@ class basic_string
       const_reference operator[](size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->size() > n);
-      return *(this->priv_addr() + n);
+      return *(this->priv_addr() + difference_type(n));
    }
 
    //! <b>Requires</b>: size() > n.
@@ -1341,7 +1353,7 @@ class basic_string
    {
       if (n >= this->size())
          throw_out_of_range("basic_string::at invalid subscript");
-      return *(this->priv_addr() + n);
+      return *(this->priv_addr() + difference_type(n));
    }
 
    //! <b>Requires</b>: size() > n.
@@ -1356,7 +1368,7 @@ class basic_string
       const_reference at(size_type n) const {
       if (n >= this->size())
          throw_out_of_range("basic_string::at invalid subscript");
-      return *(this->priv_addr() + n);
+      return *(this->priv_addr() + difference_type(n));
    }
 
    //////////////////////////////////////////////
@@ -1439,7 +1451,7 @@ class basic_string
    //!
    //! <b>Returns</b>: *this
    basic_string& append(const CharT* s, size_type n)
-   {  return this->append(s, s + n);  }
+   {  return this->append(s, s + difference_type(n));  }
 
    //! <b>Requires</b>: s points to an array of at least traits::length(s) + 1 elements of CharT.
    //!
@@ -1480,9 +1492,9 @@ class basic_string
       const size_type old_size = this->priv_size();
       if (old_size < this->capacity()){
          const pointer addr = this->priv_addr();
-         this->priv_construct_null(addr + old_size + 1);
+         this->priv_construct_null(addr + difference_type(old_size + 1u));
-         Traits::assign(addr[old_size], c);
+         Traits::assign(addr[difference_type(old_size)], c);
-         this->priv_size(old_size+1);
+         this->priv_size(old_size+1u);
       }
       else{
          //No enough memory, insert a new object at the end
@@ -1538,7 +1550,7 @@ class basic_string
    //!
    //! <b>Returns</b>: *this
    basic_string& assign(const CharT* s, size_type n)
-   {  return this->assign(s, s + n);   }
+   {  return this->assign(s, s + difference_type(n));   }
 
    //! <b>Requires</b>: s points to an array of at least traits::length(s) + 1 elements of CharT.
    //!
@@ -1563,7 +1575,7 @@ class basic_string
        this->reserve(n);
        CharT* ptr = boost::movelib::to_raw_pointer(this->priv_addr());
        Traits::copy(ptr, first, n);
-       this->priv_construct_null(ptr + n);
+       this->priv_construct_null(ptr + difference_type(n));
        this->priv_size(n);
        return *this;
     }
@@ -1589,7 +1601,7 @@ class basic_string
          ++ptr;
       }
       if (first == last)
-         this->erase(addr + cur, addr + old_size);
+         this->erase(addr + difference_type(cur), addr + difference_type(old_size));
       else
          this->append(first, last);
       return *this;
@@ -1662,7 +1674,7 @@ class basic_string
          throw_out_of_range("basic_string::insert out of range position");
       if (this->size() > this->max_size() - n)
          throw_length_error("basic_string::insert max_size() exceeded");
-      this->insert(this->priv_addr() + pos, s, s + n);
+      this->insert(this->priv_addr() + pos, s, s + difference_type(n));
       return *this;
    }
 
@@ -1714,7 +1726,7 @@ class basic_string
    //! <b>Returns</b>: An iterator which refers to the copy of the inserted character.
    iterator insert(const_iterator p, CharT c)
    {
-      size_type new_offset = p - this->priv_addr();
+      size_type new_offset = size_type(p - this->priv_addr());
       this->insert(p, cvalue_iterator(c, 1), cvalue_iterator());
       return this->priv_addr() + new_offset;
    }
@@ -1747,7 +1759,7 @@ class basic_string
       for ( ; first != last; ++first, ++p) {
          p = this->insert(p, *first);
       }
-      return this->begin() + n_pos;
+      return this->begin() + difference_type(n_pos);
    }
 
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -1760,9 +1772,9 @@ class basic_string
          >::type * = 0
       )
    {
-      const size_type n_pos = p - this->cbegin();
+      const size_type n_pos = size_type(p - this->cbegin());
       if (first != last) {
-         const size_type n = boost::container::iterator_distance(first, last);
+         const size_type n = boost::container::iterator_udistance(first, last);
          const size_type old_size = this->priv_size();
          const size_type remaining = this->capacity() - old_size;
          const pointer old_start = this->priv_addr();
@@ -1780,7 +1792,7 @@ class basic_string
             new_cap  = this->next_capacity(n);
             hint = old_start;
             allocation_ret = this->allocation_command
-                  (allocate_new | expand_fwd | expand_bwd, old_size + n + 1, new_cap, hint);
+                  (allocate_new | expand_fwd | expand_bwd, old_size + n + 1u, new_cap, hint);
 
             //Check forward expansion
             if(old_start == allocation_ret){
@@ -1791,29 +1803,29 @@ class basic_string
 
          //Reuse same buffer
          if(enough_capacity){
-            const size_type elems_after = old_size - (p - old_start);
+            const size_type elems_after = old_size - size_type(p - old_start);
             const size_type old_length = old_size;
             if (elems_after >= n) {
-               const pointer pointer_past_last = old_start + old_size + 1;
+               const pointer pointer_past_last = old_start + difference_type(old_size + 1u);
-               priv_uninitialized_copy(old_start + (old_size - n + 1),
+               priv_uninitialized_copy(old_start + difference_type(old_size - n + 1u),
                                        pointer_past_last, pointer_past_last);
 
                this->priv_size(old_size+n);
-               Traits::move(const_cast<CharT*>(boost::movelib::to_raw_pointer(p + n)),
+               Traits::move(const_cast<CharT*>(boost::movelib::to_raw_pointer(p + difference_type(n))),
                            boost::movelib::to_raw_pointer(p),
-                           (elems_after - n) + 1);
+                           (elems_after - n) + 1u);
                this->priv_copy(first, last, const_cast<CharT*>(boost::movelib::to_raw_pointer(p)));
             }
             else {
                ForwardIter mid = first;
-               boost::container::iterator_advance(mid, elems_after + 1);
+               boost::container::iterator_uadvance(mid, elems_after + 1u);
 
-               priv_uninitialized_copy(mid, last, old_start + old_size + 1);
+               priv_uninitialized_copy(mid, last, old_start + difference_type(old_size + 1u));
                const size_type newer_size = old_size + (n - elems_after);
                this->priv_size(newer_size);
                priv_uninitialized_copy
-                  (p, const_iterator(old_start + old_length + 1),
+                  (p, const_iterator(old_start + difference_type(old_length + 1u)),
-                  old_start + newer_size);
+                  old_start + difference_type(newer_size));
                this->priv_size(newer_size + elems_after);
                this->priv_copy(first, mid, const_cast<CharT*>(boost::movelib::to_raw_pointer(p)));
             }
@@ -1827,11 +1839,11 @@ class basic_string
                new_length += priv_uninitialized_copy
                               (const_iterator(old_start), p, new_start);
                new_length += priv_uninitialized_copy
-                              (first, last, new_start + new_length);
+                              (first, last, new_start + difference_type(new_length));
                new_length += priv_uninitialized_copy
-                              (p, const_iterator(old_start + old_size),
+                              (p, const_iterator(old_start + difference_type(old_size)),
-                              new_start + new_length);
+                              new_start + difference_type(new_length));
-               this->priv_construct_null(new_start + new_length);
+               this->priv_construct_null(new_start + difference_type(new_length));
 
                this->deallocate_block();
                this->assure_long();
@@ -1845,14 +1857,14 @@ class basic_string
                value_type * const oldbuf     = boost::movelib::to_raw_pointer(old_start);
                value_type * const newbuf     = boost::movelib::to_raw_pointer(new_start);
                const value_type *const pos   = boost::movelib::to_raw_pointer(p);
-               const size_type before  = pos - oldbuf;
+               const size_type before  = size_type(pos - oldbuf);
 
                //First move old data
                Traits::move(newbuf, oldbuf, before);
-               Traits::move(newbuf + before + n, pos, old_size - before);
+               Traits::move(newbuf + difference_type(before + n), pos, old_size - before);
                //Now initialize the new data
-               priv_uninitialized_copy(first, last, new_start + before);
+               priv_uninitialized_copy(first, last, new_start + difference_type(before));
-               this->priv_construct_null(new_start + (old_size + n));
+               this->priv_construct_null(new_start + difference_type(old_size + n));
                this->assure_long();
                this->priv_long_addr(new_start);
                this->priv_long_size(old_size + n);
@@ -1860,7 +1872,7 @@ class basic_string
             }
          }
       }
-      return this->begin() + n_pos;
+      return this->begin() + difference_type(n_pos);
    }
    #endif
 
@@ -1903,7 +1915,7 @@ class basic_string
       if (pos > this->size())
          throw_out_of_range("basic_string::erase out of range position");
       const pointer addr = this->priv_addr();
-      erase(addr + pos, addr + pos + dtl::min_value(n, this->size() - pos));
+      erase(addr + difference_type(pos), addr + difference_type(pos) + dtl::min_value(n, this->size() - pos));
       return *this;
    }
 
@@ -1920,8 +1932,8 @@ class basic_string
       const size_type old_size = this->priv_size();
       Traits::move(ptr,
                    boost::movelib::to_raw_pointer(p + 1),
-                   old_size - (p - this->priv_addr()));
+                   old_size - size_type(p - this->priv_addr()));
-      this->priv_size(old_size-1);
+      this->priv_size(old_size-1u);
       return iterator(ptr);
    }
 
@@ -1937,11 +1949,11 @@ class basic_string
    {
       CharT * f = const_cast<CharT*>(boost::movelib::to_raw_pointer(first));
       if (first != last) { // The move includes the terminating null.
-         const size_type num_erased = last - first;
+         const size_type num_erased = size_type(last - first);
          const size_type old_size = this->priv_size();
          Traits::move(f,
                       boost::movelib::to_raw_pointer(last),
-                      (old_size + 1)-(last - this->priv_addr()));
+                      old_size + 1u - size_type(last - this->priv_addr()));
          const size_type new_length = old_size - num_erased;
          this->priv_size(new_length);
       }
@@ -1980,8 +1992,8 @@ class basic_string
       if (this->size() - len >= this->max_size() - str.size())
          throw_length_error("basic_string::replace max_size() exceeded");
       const pointer addr = this->priv_addr();
-      return this->replace( const_iterator(addr + pos1)
+      return this->replace( const_iterator(addr + difference_type(pos1))
-                          , const_iterator(addr + pos1 + len)
+                          , const_iterator(addr + difference_type(pos1 + len))
                           , str.begin(), str.end());
    }
 
@@ -2048,7 +2060,7 @@ class basic_string
       if (n2 > max_size || (this->size() - len) >= (max_size - n2))
          throw_length_error("basic_string::replace max_size() exceeded");
       const pointer addr = this->priv_addr() + pos1;
-      return this->replace(addr, addr + len, s, s + n2);
+      return this->replace(addr, addr + difference_type(len), s, s + difference_type(n2));
    }
 
    //! <b>Requires</b>: pos1 <= size() and s points to an array of at least n2 elements of CharT.
@@ -2086,7 +2098,7 @@ class basic_string
       if (n2 > this->max_size() || this->size() - len >= this->max_size() - n2)
          throw_length_error("basic_string::replace max_size() exceeded");
       const pointer addr    = this->priv_addr();
-      return this->replace(addr + pos1, addr + pos1 + len, n2, c);
+      return this->replace(addr + difference_type(pos1), addr + difference_type(pos1 + len), n2, c);
    }
 
    //! <b>Requires</b>: [begin(),i1) and [i1,i2) are valid ranges.
@@ -2108,7 +2120,7 @@ class basic_string
    //!
    //! <b>Returns</b>: *this
    BOOST_CONTAINER_FORCEINLINE basic_string& replace(const_iterator i1, const_iterator i2, const CharT* s, size_type n)
-   { return this->replace(i1, i2, s, s + n); }
+   { return this->replace(i1, i2, s, s + difference_type(n)); }
 
    //! <b>Requires</b>: [begin(),i1) and [i1,i2) are valid ranges and s points to an
    //!   array of at least traits::length(s) + 1 elements of CharT.
@@ -2133,7 +2145,7 @@ class basic_string
       const size_type len = static_cast<size_type>(i2 - i1);
       if (len >= n) {
          Traits::assign(const_cast<CharT*>(boost::movelib::to_raw_pointer(i1)), n, c);
-         erase(i1 + n, i2);
+         erase(i1 + difference_type(n), i2);
       }
       else {
          Traits::assign(const_cast<CharT*>(boost::movelib::to_raw_pointer(i1)), len, c);
@@ -2185,7 +2197,7 @@ class basic_string
       const difference_type len = i2 - i1;
       if (len >= n) {
          this->priv_copy(j1, j2, const_cast<CharT*>(boost::movelib::to_raw_pointer(i1)));
-         this->erase(i1 + n, i2);
+         this->erase(i1 + difference_type(n), i2);
       }
       else {
          ForwardIter m = j1;
@@ -2350,12 +2362,12 @@ class basic_string
          return npos;
       else {
          const pointer addr = this->priv_addr();
-         pointer finish = addr + this->priv_size();
+         pointer finish = addr + difference_type(this->priv_size());
          const const_iterator result =
-            boost::container::search(boost::movelib::to_raw_pointer(addr + pos),
+            boost::container::search(boost::movelib::to_raw_pointer(addr + difference_type(pos)),
                    boost::movelib::to_raw_pointer(finish),
-                   s, s + n, Eq_traits<Traits>());
+                   s, s + difference_type(n), Eq_traits<Traits>());
-         return result != finish ? result - begin() : npos;
+         return result != finish ? size_type(result - begin()) : npos;
       }
    }
 
@@ -2379,11 +2391,11 @@ class basic_string
          return npos;
       else {
          const pointer addr    = this->priv_addr();
-         pointer finish = addr + sz;
+         pointer finish = addr + difference_type(sz);
          const const_iterator result =
-            boost::container::find_if(addr + pos, finish,
+            boost::container::find_if(addr + difference_type(pos), finish,
                   boost::container::bind2nd(Eq_traits<Traits>(), c));
-         return result != finish ? result - begin() : npos;
+         return result != finish ? size_type(result - begin()) : npos;
       }
    }
 
@@ -2427,10 +2439,10 @@ class basic_string
       else if (n == 0)
          return dtl::min_value(len, pos);
       else {
-         const const_iterator last = begin() + dtl::min_value(len - n, pos) + n;
+         const const_iterator last = begin() + difference_type(dtl::min_value(len - n, pos + n));
          const const_iterator result = boost::container::find_end
-            (begin(), last, s, s + n, Eq_traits<Traits>());
+            (begin(), last, s, s + difference_type(n), Eq_traits<Traits>());
-         return result != last ? result - begin() : npos;
+         return result != last ? size_type(result - begin()) : npos;
       }
    }
 
@@ -2459,7 +2471,7 @@ class basic_string
          const_reverse_iterator rresult =
             boost::container::find_if(const_reverse_iterator(last), rend(),
                   boost::container::bind2nd(Eq_traits<Traits>(), c));
-         return rresult != rend() ? (rresult.base() - 1) - begin() : npos;
+         return rresult != rend() ? size_type((rresult.base() - 1) - begin()) : npos;
       }
    }
 
@@ -2499,10 +2511,10 @@ class basic_string
          return npos;
       else {
          const pointer addr    = this->priv_addr();
-         pointer finish = addr + sz;
+         pointer finish = addr + difference_type(sz);
          const_iterator result = boost::container::find_first_of
-            (addr + pos, finish, s, s + n, Eq_traits<Traits>());
+            (addr + difference_type(pos), finish, s, s + difference_type(n), Eq_traits<Traits>());
-         return result != finish ? result - this->begin() : npos;
+         return result != finish ? size_type(result - this->begin()) : npos;
       }
    }
 
@@ -2561,11 +2573,11 @@ class basic_string
          return npos;
       else {
          const pointer addr    = this->priv_addr();
-         const const_iterator last = addr + dtl::min_value(len - 1, pos) + 1;
+         const const_iterator last = addr + difference_type(dtl::min_value(len - 1, pos) + 1);
          const const_reverse_iterator rresult =
             boost::container::find_first_of(const_reverse_iterator(last), rend(),
-                               s, s + n, Eq_traits<Traits>());
+                               s, s + difference_type(n), Eq_traits<Traits>());
-         return rresult != rend() ? (rresult.base() - 1) - addr : npos;
+         return rresult != rend() ? size_type((rresult.base() - 1) - addr) : npos;
       }
    }
 
@@ -2622,10 +2634,10 @@ class basic_string
          return npos;
       else {
          const pointer addr   = this->priv_addr();
-         const pointer finish = addr + this->priv_size();
+         const pointer finish = addr + difference_type(this->priv_size());
          const const_iterator result = boost::container::find_if
-            (addr + pos, finish, Not_within_traits<Traits>(s, s + n));
+            (addr + difference_type(pos), finish, Not_within_traits<Traits>(s, s + difference_type(n)));
-         return result != finish ? result - addr : npos;
+         return result != finish ? size_type(result - addr) : npos;
       }
    }
 
@@ -2648,11 +2660,11 @@ class basic_string
          return npos;
       else {
          const pointer addr   = this->priv_addr();
-         const pointer finish = addr + this->priv_size();
+         const pointer finish = addr + difference_type(this->priv_size());
          const const_iterator result
-            = boost::container::find_if(addr + pos, finish,
+            = boost::container::find_if(addr + difference_type(pos), finish,
                      boost::container::not1(boost::container::bind2nd(Eq_traits<Traits>(), c)));
-         return result != finish ? result - begin() : npos;
+         return result != finish ? size_type(result - begin()) : npos;
       }
    }
 
@@ -2695,8 +2707,8 @@ class basic_string
          const const_iterator last = begin() + dtl::min_value(len - 1, pos) + 1;
          const const_reverse_iterator rresult =
             boost::container::find_if(const_reverse_iterator(last), rend(),
-                    Not_within_traits<Traits>(s, s + n));
+                    Not_within_traits<Traits>(s, s + difference_type(n)));
-         return rresult != rend() ? (rresult.base() - 1) - begin() : npos;
+         return rresult != rend() ? size_type((rresult.base() - 1) - begin()) : npos;
       }
    }
 
@@ -2724,7 +2736,7 @@ class basic_string
          const const_reverse_iterator rresult =
             boost::container::find_if(const_reverse_iterator(last), rend(),
                   boost::container::not1(boost::container::bind2nd(Eq_traits<Traits>(), c)));
-         return rresult != rend() ? (rresult.base() - 1) - begin() : npos;
+         return rresult != rend() ? size_type((rresult.base() - 1) - begin()) : npos;
       }
    }
 
@@ -2742,8 +2754,8 @@ class basic_string
       if (pos > this->size())
          throw_out_of_range("basic_string::substr out of range position");
       const pointer addr = this->priv_addr();
-      return basic_string(addr + pos,
+      return basic_string(addr + difference_type(pos),
-                          addr + pos + dtl::min_value(n, size() - pos), this->alloc());
+                          addr + difference_type(pos + dtl::min_value(n, size() - pos)), this->alloc());
    }
 
    //! <b>Effects</b>: Determines the effective length rlen of the string to compare as
@@ -2760,7 +2772,7 @@ class basic_string
    {
       const pointer addr     = this->priv_addr();
       const pointer str_addr = str.priv_addr();
-      return this->s_compare(addr, addr + this->priv_size(), str_addr, str_addr + str.priv_size());
+      return this->s_compare(addr, addr + difference_type(this->priv_size()), str_addr, str_addr + difference_type(str.priv_size()));
    }
 
    //! <b>Throws</b>: Nothing
@@ -2771,7 +2783,7 @@ class basic_string
       int compare(BasicStringView<CharT,Traits> sv) const
    {
       const pointer addr = this->priv_addr();
-      return this->s_compare(addr, addr + this->priv_size(), sv.data(), sv.data() + sv.size());
+      return this->s_compare(addr, addr + difference_type(this->priv_size()), sv.data(), sv.data() + difference_type(sv.size()));
    }
 
    //! <b>Requires</b>: pos1 <= size()
@@ -2790,9 +2802,9 @@ class basic_string
          throw_out_of_range("basic_string::compare out of range position");
       const pointer addr    = this->priv_addr();
       const pointer str_addr = str.priv_addr();
-      return this->s_compare(addr + pos1,
+      return this->s_compare(addr + difference_type(pos1),
-                        addr + pos1 + dtl::min_value(n1, this->size() - pos1),
+                        addr + difference_type(pos1 + dtl::min_value(n1, this->size() - pos1)),
-                        str_addr, str_addr + str.priv_size());
+                        str_addr, str_addr + difference_type(str.priv_size()));
    }
 
    //! <b>Requires</b>: pos1 <= size()
@@ -2808,7 +2820,7 @@ class basic_string
          throw_out_of_range("basic_string::compare out of range position");
       const pointer addr    = this->priv_addr() + pos1;
       const CharT* str_addr = sv.data();
-      return this->s_compare(addr, addr + dtl::min_value(n1, this->size() - pos1),
+      return this->s_compare(addr, addr + difference_type(dtl::min_value(n1, this->size() - pos1)),
                        str_addr, str_addr + sv.size());
    }
 
@@ -2827,8 +2839,8 @@ class basic_string
          throw_out_of_range("basic_string::compare out of range position");
       const pointer addr     = this->priv_addr() + pos1;
       const pointer str_addr = str.priv_addr() + pos2;
-      return this->s_compare(addr, addr + dtl::min_value(n1, this->size() - pos1),
+      return this->s_compare(addr, addr + difference_type(dtl::min_value(n1, this->size() - pos1)),
-                        str_addr, str_addr + dtl::min_value(n2, str.size() - pos2));
+                             str_addr, str_addr + difference_type(dtl::min_value(n2, str.size() - pos2)));
    }
 
    //! <b>Requires</b>: pos1 <= size() and pos2 <= str.size()
@@ -2847,8 +2859,8 @@ class basic_string
          throw_out_of_range("basic_string::compare out of range position");
       const pointer addr     = this->priv_addr() + pos1;
       const CharT * str_addr = sv.data() + pos2;
-      return this->s_compare(addr, addr + dtl::min_value(n1, this->size() - pos1),
+      return this->s_compare(addr, addr + difference_type(dtl::min_value(n1, this->size() - pos1)),
-                       str_addr, str_addr + dtl::min_value(n2, sv.size() - pos2));
+                       str_addr, str_addr + difference_type(dtl::min_value(n2, sv.size() - pos2)));
    }
 
    //! <b>Throws</b>: Nothing
@@ -2858,7 +2870,7 @@ class basic_string
       int compare(const CharT* s) const
    {
       const pointer addr = this->priv_addr();
-      return this->s_compare(addr, addr + this->priv_size(), s, s + Traits::length(s));
+      return this->s_compare(addr, addr + difference_type(this->priv_size()), s, s + Traits::length(s));
    }
 
    //! <b>Requires</b>: pos1 > size() and s points to an array of at least n2 elements of CharT.
@@ -2872,9 +2884,9 @@ class basic_string
       if (pos1 > this->size())
          throw_out_of_range("basic_string::compare out of range position");
       const pointer addr = this->priv_addr();
-      return this->s_compare( addr + pos1,
+      return this->s_compare( addr + difference_type(pos1),
-                        addr + pos1 + dtl::min_value(n1, this->size() - pos1),
+                        addr + difference_type(pos1 + dtl::min_value(n1, this->size() - pos1)),
-                        s, s + n2);
+                        s, s + difference_type(n2));
    }
 
    //! <b>Requires</b>: pos1 > size() and s points to an array of at least traits::length(s) + 1 elements of CharT.
@@ -2903,9 +2915,9 @@ class basic_string
 
          const pointer addr = this->priv_addr();
          new_length += priv_uninitialized_copy
-            (addr, addr + this->priv_size(), new_start);
+            (addr, addr + difference_type(this->priv_size()), new_start);
          if(null_terminate){
-            this->priv_construct_null(new_start + new_length);
+            this->priv_construct_null(new_start + difference_type(new_length));
          }
          this->deallocate_block();
          this->assure_long();
@@ -2918,8 +2930,8 @@ class basic_string
    template<class It1, class It2>
    static int s_compare(It1 f1, It1 l1, It2 f2, It2 l2)
    {
-      const difference_type n1 = l1 - f1;
+      const std::size_t n1 = std::size_t(l1 - f1);
-      const difference_type n2 = l2 - f2;
+      const std::size_t n2 = std::size_t(l2 - f2);
       const int cmp = Traits::compare(boost::movelib::to_raw_pointer(f1),
                                       boost::movelib::to_raw_pointer(f2),
                                       dtl::min_value(n1, n2));
@@ -3031,7 +3043,7 @@ class basic_string
    }
 
    BOOST_CONTAINER_FORCEINLINE void priv_copy(const CharT* first, const CharT* last, CharT* result)
-   {  Traits::copy(result, first, last - first);  }
+   {  Traits::copy(result, first, std::size_t(last - first));  }
 
    template <class Integer>
    BOOST_CONTAINER_FORCEINLINE basic_string& priv_replace_dispatch(const_iterator first, const_iterator last,

include/boost/container/vector.hpp

@@ -94,6 +94,7 @@ class vec_iterator
    typedef typename boost::intrusive::pointer_traits<Pointer>::element_type         element_type;
    #endif
    typedef typename boost::intrusive::pointer_traits<Pointer>::difference_type      difference_type;
+   typedef typename boost::intrusive::pointer_traits<Pointer>::size_type            size_type;
    typedef typename dtl::if_c
       < IsConst
       , typename boost::intrusive::pointer_traits<Pointer>::template
@@ -194,6 +195,7 @@ class vec_iterator
       friend vec_iterator operator-(vec_iterator left, difference_type off) BOOST_NOEXCEPT_OR_NOTHROW
    {  BOOST_ASSERT(left.m_ptr || !off); left.m_ptr -= off;  return left; }
 
+   //Difference
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE
       friend difference_type operator-(const vec_iterator &left, const vec_iterator& right) BOOST_NOEXCEPT_OR_NOTHROW
    {  return left.m_ptr - right.m_ptr;   }
@@ -417,10 +419,10 @@ struct vector_alloc_holder
       {  this->m_size = static_cast<stored_size_type>(s);   }
 
    BOOST_CONTAINER_FORCEINLINE void dec_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
-      {  this->m_size -= static_cast<stored_size_type>(s);   }
+      {  this->m_size = static_cast<stored_size_type>(this->m_size - s);   }
 
    BOOST_CONTAINER_FORCEINLINE void inc_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
-      {  this->m_size += static_cast<stored_size_type>(s);   }
+      {  this->m_size = static_cast<stored_size_type>(this->m_size + s);   }
 
    BOOST_CONTAINER_FORCEINLINE void set_stored_capacity(size_type c) BOOST_NOEXCEPT_OR_NOTHROW
       {  this->m_capacity = static_cast<stored_size_type>(c);  }
@@ -450,7 +452,7 @@ struct vector_alloc_holder
    bool try_expand_fwd(size_type at_least)
    {
       //There is not enough memory, try to expand the old one
-      const size_type new_cap = this->capacity() + at_least;
+      const size_type new_cap = size_type(this->capacity() + at_least);
       size_type real_cap = new_cap;
       pointer reuse = this->start();
       bool const success = !!this->allocation_command(expand_fwd, new_cap, real_cap, reuse);
@@ -470,8 +472,8 @@ struct vector_alloc_holder
       BOOST_ASSERT(additional_objects > size_type(this->m_capacity - this->m_size));
       size_type max = allocator_traits_type::max_size(this->alloc());
       (clamp_by_stored_size_type<size_type>)(max, stored_size_type());
-      const size_type remaining_cap = max - size_type(this->m_capacity);
+      const size_type remaining_cap = size_type(max - size_type(this->m_capacity));
-      const size_type min_additional_cap = additional_objects - size_type(this->m_capacity - this->m_size);
+      const size_type min_additional_cap = size_type(additional_objects - size_type(this->m_capacity - this->m_size));
 
       if ( remaining_cap < min_additional_cap )
          boost::container::throw_length_error("get_next_capacity, allocator's max size reached");
@@ -647,10 +649,10 @@ struct vector_alloc_holder<Allocator, StoredSizeType, version_0>
       {  this->m_size = static_cast<stored_size_type>(s);   }
 
    BOOST_CONTAINER_FORCEINLINE void dec_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
-      {  this->m_size -= static_cast<stored_size_type>(s);   }
+      {  this->m_size = static_cast<stored_size_type>(this->m_size - s);   }
 
    BOOST_CONTAINER_FORCEINLINE void inc_stored_size(size_type s) BOOST_NOEXCEPT_OR_NOTHROW
-      {  this->m_size += static_cast<stored_size_type>(s);   }
+      {  this->m_size = static_cast<stored_size_type>(this->m_size + s);   }
 
    BOOST_CONTAINER_FORCEINLINE void priv_first_allocation(size_type cap)
    {
@@ -813,7 +815,7 @@ private:
    private:
    BOOST_COPYABLE_AND_MOVABLE(vector)
    typedef vector_value_traits<allocator_type> value_traits;
-   typedef constant_iterator<T, difference_type>            cvalue_iterator;
+   typedef constant_iterator<T>            cvalue_iterator;
 
    protected:
 
@@ -1290,9 +1292,10 @@ private:
          >::type * = 0)
       )
    {
+      typedef typename iterator_traits<FwdIt>::size_type it_size_type;
       //For Fwd iterators the standard only requires EmplaceConstructible and assignable from *first
       //so we can't do any backwards allocation
-      const typename iterator_traits<FwdIt>::size_type sz = boost::container::iterator_distance(first, last);
+      const it_size_type sz = boost::container::iterator_udistance(first, last);
       if (sz > size_type(-1)){
          boost::container::throw_length_error("vector::assign, FwdIt's max length reached");
       }
@@ -1400,7 +1403,7 @@ private:
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE iterator end() BOOST_NOEXCEPT_OR_NOTHROW
    {
       iterator it (this->m_holder.start());
-      it += this->m_holder.m_size;
+      it += difference_type(this->m_holder.m_size);
       return it;  //Adding zero to null pointer is allowed (non-UB)
    }
 
@@ -1464,7 +1467,7 @@ private:
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE const_iterator cend() const BOOST_NOEXCEPT_OR_NOTHROW
    {
       const_iterator it (this->m_holder.start());
-      it += this->m_holder.m_size;
+      it += difference_type(this->m_holder.m_size);
       return it;  //Adding zero to null pointer is allowed (non-UB)
    }
 
@@ -1621,7 +1624,7 @@ private:
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE reference back() BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(!this->empty());
-      return this->m_holder.start()[this->m_holder.m_size - 1];
+      return this->m_holder.start()[difference_type(this->m_holder.m_size - 1u)];
    }
 
    //! <b>Requires</b>: !empty()
@@ -1649,7 +1652,7 @@ private:
    BOOST_CONTAINER_ATTRIBUTE_NODISCARD BOOST_CONTAINER_FORCEINLINE reference operator[](size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->m_holder.m_size > n);
-      return this->m_holder.start()[n];
+      return this->m_holder.start()[difference_type(n)];
    }
 
    //! <b>Requires</b>: size() > n.
@@ -1682,7 +1685,7 @@ private:
       iterator nth(size_type n) BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->m_holder.m_size >= n);
-      return iterator(this->m_holder.start()+n);
+      return iterator(this->m_holder.start()+difference_type(n));
    }
 
    //! <b>Requires</b>: size() >= n.
@@ -1700,7 +1703,7 @@ private:
       const_iterator nth(size_type n) const BOOST_NOEXCEPT_OR_NOTHROW
    {
       BOOST_ASSERT(this->m_holder.m_size >= n);
-      return const_iterator(this->m_holder.start()+n);
+      return const_iterator(this->m_holder.start()+difference_type(n));
    }
 
    //! <b>Requires</b>: begin() <= p <= end().
@@ -1990,13 +1993,13 @@ private:
       )
    {
       BOOST_ASSERT(this->priv_in_range_or_end(pos));
-      const size_type n_pos = pos - this->cbegin();
+      const size_type n_pos = size_type(pos - this->cbegin());
       iterator it(vector_iterator_get_ptr(pos));
       for(;first != last; ++first){
          it = this->emplace(it, *first);
          ++it;
       }
-      return iterator(this->m_holder.start() + n_pos);
+      return iterator(this->m_holder.start() + difference_type(n_pos));
    }
 
    #if !defined(BOOST_CONTAINER_DOXYGEN_INVOKED)
@@ -2009,8 +2012,9 @@ private:
          >::type * = 0
       )
    {
+      typedef typename iterator_traits<FwdIt>::size_type it_size_type;
       BOOST_ASSERT(this->priv_in_range_or_end(pos));
-      const typename iterator_traits<FwdIt>::size_type sz = boost::container::iterator_distance(first, last);
+      const it_size_type sz = boost::container::iterator_udistance(first, last);
       if (sz > size_type(-1)){
          boost::container::throw_length_error("vector::insert, FwdIt's max length reached");
       }
@@ -2041,7 +2045,7 @@ private:
    {
       BOOST_ASSERT(this->priv_in_range_or_end(pos));
       BOOST_ASSERT(dtl::is_input_iterator<InIt>::value ||
-                   num == static_cast<size_type>(boost::container::iterator_distance(first, last)));
+                   num == boost::container::iterator_udistance(first, last));
       (void)last;
       dtl::insert_range_proxy<allocator_type, InIt, T*> proxy(first);
       return this->priv_insert_forward_range(vector_iterator_get_ptr(pos), num, proxy);
@@ -2223,7 +2227,7 @@ private:
    bool stable_reserve(size_type new_cap)
    {
       const size_type cp = this->capacity();
-      return cp >= new_cap || (alloc_version::value == 2 && this->m_holder.try_expand_fwd(new_cap - cp));
+      return cp >= new_cap || (alloc_version::value == 2 && this->m_holder.try_expand_fwd(size_type(new_cap - cp)));
    }
 
    //Absolutely experimental. This function might change, disappear or simply crash!
@@ -2247,7 +2251,7 @@ private:
       size_type const free_cap = c - s;
       //If not input iterator and new elements don't fit in the remaining capacity, merge in new buffer
       if(!dtl::is_input_iterator<InputIt>::value &&
-         free_cap < (n = static_cast<size_type>(boost::container::iterator_distance(first, last)))){
+         free_cap < (n = boost::container::iterator_udistance(first, last))){
          this->priv_merge_in_new_buffer(first, n, comp, alloc_version());
       }
       else{
@@ -2433,12 +2437,12 @@ private:
    {  return this->m_holder.m_size != this->m_holder.capacity();   }
 
    BOOST_CONTAINER_FORCEINLINE pointer back_ptr() const
-   {  return this->m_holder.start() + this->m_holder.m_size;  }
+   {  return this->m_holder.start() + difference_type(this->m_holder.m_size);  }
 
    BOOST_CONTAINER_FORCEINLINE size_type priv_index_of(pointer p) const
    {
       BOOST_ASSERT(this->m_holder.start() <= p);
-      BOOST_ASSERT(p <= (this->m_holder.start()+this->size()));
+      BOOST_ASSERT(p <= (this->m_holder.start()+difference_type(this->size())));
       return static_cast<size_type>(p - this->m_holder.start());
    }
 
@@ -2622,7 +2626,7 @@ private:
             ++this->num_expand_bwd;
             #endif
             this->priv_insert_forward_range_expand_backwards
-               ( new_mem , real_cap, ins_pos, 0, this->priv_dummy_empty_proxy());
+               ( new_mem, real_cap, ins_pos, 0, this->priv_dummy_empty_proxy());
          }
          else{ //New buffer
             #ifdef BOOST_CONTAINER_VECTOR_ALLOC_STATS
@@ -2750,7 +2754,7 @@ private:
       ++this->num_alloc;
       #endif
       this->priv_insert_forward_range_new_allocation(new_buf, new_cap, raw_pos, n, insert_range_proxy);
-      return iterator(this->m_holder.start() + n_pos);
+      return iterator(this->m_holder.start() + difference_type(n_pos));
    }
 
    template <class InsertionProxy>
@@ -2758,14 +2762,14 @@ private:
       (T *const raw_pos, const size_type n, const InsertionProxy insert_range_proxy, version_2)
    {
       //Check if we have enough memory or try to expand current memory
-      const size_type n_pos = raw_pos - this->priv_raw_begin();
+      const size_type n_pos = size_type(raw_pos - this->priv_raw_begin());
 
       //There is not enough memory, allocate a new
       //buffer or expand the old one.
       size_type real_cap = this->m_holder.template next_capacity<growth_factor_type>(n);
       pointer reuse(this->m_holder.start());
       pointer const ret (this->m_holder.allocation_command
-         (allocate_new | expand_fwd | expand_bwd, this->m_holder.m_size + n, real_cap, reuse));
+         (allocate_new | expand_fwd | expand_bwd, size_type(this->m_holder.m_size + n), real_cap, reuse));
 
       //Buffer reallocated
       if(reuse){
@@ -2797,7 +2801,7 @@ private:
             ( boost::movelib::to_raw_pointer(ret), real_cap, raw_pos, n, insert_range_proxy);
       }
 
-      return iterator(this->m_holder.start() + n_pos);
+      return iterator(this->m_holder.start() + (difference_type)(n_pos));
    }
 
    template <class InsertionProxy>
@@ -2843,10 +2847,10 @@ private:
       const size_type sz = this->m_holder.m_size;
       if (new_size < sz){
          //Destroy last elements
-         this->priv_destroy_last_n(sz - new_size);
+         this->priv_destroy_last_n(size_type(sz - new_size));
       }
       else {
-         this->priv_insert_forward_range(this->back_ptr(), new_size - sz, this->priv_resize_proxy(u));
+         this->priv_insert_forward_range(this->back_ptr(), size_type(new_size - sz), this->priv_resize_proxy(u));
       }
    }
 
@@ -2922,7 +2926,9 @@ private:
          //All uninitialized_moved
          ::boost::container::uninitialized_move_alloc
             (this->m_holder.alloc(), first_ptr, last_ptr, first_ptr + shift_count);
-         hole_size = first_pos + shift_count - limit_pos;
+         //Cast in case size_type is narrower than int, promotions are applied
+         //and Wconversion is in place
+         hole_size = static_cast<size_type>(first_pos + shift_count - limit_pos);
       }
       //Case C:
       else{
@@ -3024,7 +3030,7 @@ private:
       //We can have 8 possibilities:
       const size_type elemsbefore = static_cast<size_type>(pos - old_start);
       const size_type s_before    = static_cast<size_type>(old_start - new_start);
-      const size_type before_plus_new = elemsbefore + n;
+      const size_type before_plus_new = size_type(elemsbefore + n);
 
       typedef typename value_traits::ArrayDestructor array_destructor_t;
 
@@ -3039,7 +3045,7 @@ private:
          this->m_holder.set_stored_size(elemsbefore);
          insert_range_proxy.uninitialized_copy_n_and_update(a, new_elem_pos, n);
          this->m_holder.set_stored_size(before_plus_new);
-         const size_type new_size = old_size + n;
+         const size_type new_size = size_type(old_size + n);
          //Check if s_before is so big that even copying the old data + new data
          //there is a gap between the new data and the old data
          if(s_before >= new_size){
@@ -3174,7 +3180,7 @@ private:
                   old_values_destroyer.shrink_forward(old_size - (s_before - n));
                }
             }
-            this->m_holder.set_stored_size(old_size + new_1st_range);
+            this->m_holder.set_stored_size(size_type(old_size + new_1st_range));
             //Now copy the second part of old_begin overwriting itself
             T *const next = ::boost::container::move(old_start + s_before, pos, old_start);
             //Now copy the new_beg elements
@@ -3216,11 +3222,11 @@ private:
             T * const new_pos = ::boost::container::uninitialized_move_alloc
                (a, old_start, pos, new_start);
             this->m_holder.set_stored_size(elemsbefore);
-            const size_type mid_n = s_before - elemsbefore;
+            const size_type mid_n = size_type(s_before - elemsbefore);
             insert_range_proxy.uninitialized_copy_n_and_update(a, new_pos, mid_n);
             //The buffer is all constructed until old_end,
             //release destroyer
-            this->m_holder.set_stored_size(old_size + s_before);
+            this->m_holder.set_stored_size(size_type(old_size + s_before));
             old_values_destroyer.release();
 
             if(do_after){
@@ -3229,7 +3235,7 @@ private:
             }
             else{
                //Copy all new elements
-               const size_type rest_new = n - mid_n;
+               const size_type rest_new = size_type(n - mid_n);
                insert_range_proxy.copy_n_and_update(a, old_start, rest_new);
 
                T* const move_start = old_start + rest_new;
@@ -3240,7 +3246,7 @@ private:
                                  //trivial_dctr_after_move is true
                //Destroy remaining moved elements from old_end except if they
                //have trivial destructor after being moved
-               const size_type n_destroy = s_before - n;
+               const size_type n_destroy = size_type(s_before - n);
                BOOST_IF_CONSTEXPR(!value_traits::trivial_dctr_after_move){
                   boost::container::destroy_alloc_n(a, move_end, n_destroy);
                }
@@ -3267,8 +3273,8 @@ private:
             //| old_begin      +       new            | old_end |raw |
             //|_______________________________________|_________|____|
             //
-            const size_type n_after    = n - s_before;
+            const size_type n_after    = size_type(n - s_before);
-            const size_type elemsafter = old_size - elemsbefore;
+            const size_type elemsafter = size_type(old_size - elemsbefore);
 
             //We can have two situations:
             if (elemsafter >= n_after){
@@ -3308,7 +3314,7 @@ private:
                //|__________________________|_______________|________|_________|
 
                //First initialize data in raw memory
-               const size_type mid_last_dist = n_after - elemsafter;
+               const size_type mid_last_dist = size_type(n_after - elemsafter);
 
                //Copy to the old_end part to the uninitialized zone leaving a gap.
                ::boost::container::uninitialized_move_alloc(a, pos, old_finish, old_finish + mid_last_dist);

test/alloc_full_test.cpp

@@ -21,7 +21,7 @@
 
 namespace boost { namespace container { namespace test {
 
-static const int NumIt = 200;
+static const std::size_t NumIt = 200;
 
 enum deallocation_type { DirectDeallocation, InverseDeallocation, MixedDeallocation, EndDeallocationType };
 
@@ -39,7 +39,7 @@ bool test_allocation()
       std::vector<void*> buffers;
       //std::size_t free_memory = a.get_free_memory();
 
-      for(int i = 0; i != NumIt; ++i){
+      for(std::size_t i = 0; i != NumIt; ++i){
          void *ptr = dlmalloc_malloc(i);
          if(!ptr)
             break;
@@ -49,7 +49,7 @@ bool test_allocation()
       switch(t){
          case DirectDeallocation:
          {
-            for(int j = 0, max = (int)buffers.size()
+            for(std::size_t j = 0, max = buffers.size()
                ;j < max
                ;++j){
                dlmalloc_free(buffers[j]);
@@ -58,7 +58,7 @@ bool test_allocation()
          break;
          case InverseDeallocation:
          {
-            for(int j = (int)buffers.size()
+            for(std::size_t j = buffers.size()
                ;j--
                ;){
                dlmalloc_free(buffers[j]);
@@ -67,12 +67,12 @@ bool test_allocation()
          break;
          case MixedDeallocation:
          {
-            for(int j = 0, max = (int)buffers.size()
+            for(std::size_t j = 0, max = buffers.size()
                ;j < max
                ;++j){
-               int pos = (j%4)*((int)buffers.size())/4;
+               std::size_t pos = (j%4)*(buffers.size())/4;
                dlmalloc_free(buffers[pos]);
-               buffers.erase(buffers.begin()+pos);
+               buffers.erase(buffers.begin()+(std::ptrdiff_t)pos);
             }
          }
          break;
@@ -99,15 +99,15 @@ bool test_allocation_shrink()
    std::vector<void*> buffers;
 
    //Allocate buffers with extra memory
-   for(int i = 0; i != NumIt; ++i){
+   for(std::size_t i = 0; i != NumIt; ++i){
-      void *ptr = dlmalloc_malloc(i*2);
+      void *ptr = dlmalloc_malloc(i*2u);
       if(!ptr)
          break;
       buffers.push_back(ptr);
    }
 
    //Now shrink to half
-   for(int i = 0, max = (int)buffers.size()
+   for(std::size_t i = 0, max = buffers.size()
       ;i < max
       ; ++i){
       std::size_t try_received_size = 0;
@@ -137,12 +137,12 @@ bool test_allocation_shrink()
    }
 
    //Deallocate it in non sequential order
-   for(int j = 0, max = (int)buffers.size()
+   for(std::size_t j = 0, max = buffers.size()
       ;j < max
       ;++j){
-      int pos = (j%4)*((int)buffers.size())/4;
+      std::size_t pos = (j%4u)*(buffers.size())/4u;
       dlmalloc_free(buffers[pos]);
-      buffers.erase(buffers.begin()+pos);
+      buffers.erase(buffers.begin()+(std::ptrdiff_t)pos);
    }
    dlmalloc_malloc_check();
    return 0 != dlmalloc_all_deallocated();//a.all_memory_deallocated() && a.check_sanity();
@@ -158,7 +158,7 @@ bool test_allocation_expand()
    std::vector<void*> buffers;
 
    //Allocate buffers with extra memory
-   for(int i = 0; i != NumIt; ++i){
+   for(std::size_t i = 0; i != NumIt; ++i){
       void *ptr = dlmalloc_malloc(i);
       if(!ptr)
          break;
@@ -166,7 +166,7 @@ bool test_allocation_expand()
    }
 
    //Now try to expand to the double of the size
-   for(int i = 0, max = (int)buffers.size()
+   for(std::size_t i = 0, max = buffers.size()
       ;i < max
       ;++i){
       std::size_t received_size = 0;
@@ -187,12 +187,12 @@ bool test_allocation_expand()
    }
 
    //Deallocate it in non sequential order
-   for(int j = 0, max = (int)buffers.size()
+   for(std::size_t j = 0, max = buffers.size()
       ;j < max
       ;++j){
-      int pos = (j%4)*((int)buffers.size())/4;
+      std::size_t pos = (j%4u)*(buffers.size())/4u;
       dlmalloc_free(buffers[pos]);
-      buffers.erase(buffers.begin()+pos);
+      buffers.erase(buffers.begin()+(std::ptrdiff_t)pos);
    }
    dlmalloc_malloc_check();
    return 0 != dlmalloc_all_deallocated();//a.all_memory_deallocated() && a.check_sanity();
@@ -208,13 +208,13 @@ bool test_allocation_shrink_and_expand()
    std::vector<bool>        size_reduced;
 
    //Allocate buffers wand store received sizes
-   for(int i = 0; i != NumIt; ++i){
+   for(std::size_t i = 0; i != NumIt; ++i){
       std::size_t received_size = 0;
       void *ptr = dlmalloc_allocation_command
-         (BOOST_CONTAINER_ALLOCATE_NEW, 1, i, i*2, &received_size, 0).first;
+         (BOOST_CONTAINER_ALLOCATE_NEW, 1u, i, i*2u, &received_size, 0).first;
       if(!ptr){
          ptr = dlmalloc_allocation_command
-            ( BOOST_CONTAINER_ALLOCATE_NEW, 1, 1, i*2, &received_size, 0).first;
+            ( BOOST_CONTAINER_ALLOCATE_NEW, 1u, 1u, i*2, &received_size, 0).first;
          if(!ptr)
             break;
       }
@@ -223,7 +223,7 @@ bool test_allocation_shrink_and_expand()
    }
 
    //Now shrink to half
-   for(int i = 0, max = (int)buffers.size()
+   for(std::size_t i = 0, max = buffers.size()
       ; i < max
       ; ++i){
       std::size_t received_size = 0;
@@ -243,7 +243,7 @@ bool test_allocation_shrink_and_expand()
    }
 
    //Now try to expand to the original size
-   for(int i = 0, max = (int)buffers.size()
+   for(std::size_t i = 0, max = buffers.size()
       ;i < max
       ;++i){
       if(!size_reduced[i])  continue;
@@ -262,12 +262,12 @@ bool test_allocation_shrink_and_expand()
    }
 
    //Deallocate it in non sequential order
-   for(int j = 0, max = (int)buffers.size()
+   for(std::size_t j = 0, max = buffers.size()
       ;j < max
       ;++j){
-      int pos = (j%4)*((int)buffers.size())/4;
+      std::size_t pos = (j%4u)*(buffers.size())/4u;
       dlmalloc_free(buffers[pos]);
-      buffers.erase(buffers.begin()+pos);
+      buffers.erase(buffers.begin()+(std::ptrdiff_t)pos);
    }
 
    return 0 != dlmalloc_all_deallocated();//a.all_memory_deallocated() && a.check_sanity();
@@ -284,7 +284,7 @@ bool test_allocation_deallocation_expand()
    std::vector<void*> buffers;
 
    //Allocate buffers with extra memory
-   for(int i = 0; i != NumIt; ++i){
+   for(std::size_t i = 0; i != NumIt; ++i){
       void *ptr = dlmalloc_malloc(i);
       if(!ptr)
          break;
@@ -293,7 +293,7 @@ bool test_allocation_deallocation_expand()
 
    //Now deallocate the half of the blocks
    //so expand maybe can merge new free blocks
-   for(int i = 0, max = (int)buffers.size()
+   for(std::size_t i = 0, max = buffers.size()
       ;i < max
       ;++i){
       if(i%2){
@@ -303,7 +303,7 @@ bool test_allocation_deallocation_expand()
    }
 
    //Now try to expand to the double of the size
-   for(int i = 0, max = (int)buffers.size()
+   for(std::size_t i = 0, max = buffers.size()
       ;i < max
       ;++i){
       //
@@ -332,12 +332,12 @@ bool test_allocation_deallocation_expand()
                 ,buffers.end());
 
    //Deallocate it in non sequential order
-   for(int j = 0, max = (int)buffers.size()
+   for(std::size_t j = 0, max = buffers.size()
       ;j < max
       ;++j){
-      int pos = (j%4)*((int)buffers.size())/4;
+      std::size_t pos = (j%4u)*(buffers.size())/4u;
       dlmalloc_free(buffers[pos]);
-      buffers.erase(buffers.begin()+pos);
+      buffers.erase(buffers.begin()+(std::ptrdiff_t)pos);
    }
    dlmalloc_malloc_check();
    return 0 != dlmalloc_all_deallocated();//a.all_memory_deallocated() && a.check_sanity();
@@ -354,11 +354,11 @@ bool test_allocation_with_reuse()
 {
    dlmalloc_malloc_check();
    //We will repeat this test for different sized elements
-   for(int sizeof_object = 1; sizeof_object < 20; ++sizeof_object){
+   for(std::size_t sizeof_object = 1; sizeof_object < 20; ++sizeof_object){
       std::vector<void*> buffers;
 
       //Allocate buffers with extra memory
-      for(int i = 0; i != NumIt; ++i){
+      for(std::size_t i = 0; i != NumIt; ++i){
          void *ptr = dlmalloc_malloc(i*sizeof_object);
          if(!ptr)
             break;
@@ -367,7 +367,7 @@ bool test_allocation_with_reuse()
 
       //Now deallocate all except the latest
       //Now try to expand to the double of the size
-      for(int i = 0, max = (int)buffers.size() - 1
+      for(std::size_t i = 0, max = buffers.size() - 1
          ;i < max
          ;++i){
          dlmalloc_free(buffers[i]);
@@ -379,9 +379,9 @@ bool test_allocation_with_reuse()
 
       //Now allocate with reuse
       std::size_t received_size = 0;
-      for(int i = 0; i != NumIt; ++i){
+      for(std::size_t i = 0; i != NumIt; ++i){
-         std::size_t min_size = (received_size/sizeof_object + 1)*sizeof_object;
+         std::size_t min_size = (received_size/sizeof_object + 1u)*sizeof_object;
-         std::size_t prf_size = (received_size/sizeof_object + (i+1)*2)*sizeof_object;
+         std::size_t prf_size = (received_size/sizeof_object + (i+1u)*2u)*sizeof_object;
          dlmalloc_command_ret_t ret = dlmalloc_allocation_command
             ( BOOST_CONTAINER_EXPAND_BWD, sizeof_object, min_size
             , prf_size, &received_size, (char*)ptr);
@@ -413,8 +413,8 @@ bool test_aligned_allocation()
    dlmalloc_malloc_check();
    //Allocate aligned buffers in a loop
    //and then deallocate it
-   for(unsigned int i = 1; i != (1 << (sizeof(int)/2)); i <<= 1){
+   for(std::size_t i = 1u; i != (1u << (sizeof(int)/2u)); i <<= 1u){
-      for(unsigned int j = 1; j != 512; j <<= 1){
+      for(std::size_t j = 1u; j != 512u; j <<= 1){
          void *ptr = dlmalloc_memalign(i-1, j);
          if(!ptr){
             return false;
@@ -442,11 +442,11 @@ bool test_continuous_aligned_allocation()
    //Allocate aligned buffers in a loop
    //and then deallocate it
    bool continue_loop = true;
-   unsigned int MaxAlign = 4096;
+   std::size_t MaxAlign = 4096;
-   unsigned int MaxSize  = 4096;
+   std::size_t MaxSize  = 4096;
-   for(unsigned i = 1; i < MaxSize; i <<= 1){
+   for(std::size_t i = 1; i < MaxSize; i <<= 1){
-      for(unsigned int j = 1; j < MaxAlign; j <<= 1){
+      for(std::size_t j = 1; j < MaxAlign; j <<= 1){
-         for(int k = 0; k != NumIt; ++k){
+         for(std::size_t k = 0; k != NumIt; ++k){
             void *ptr = dlmalloc_memalign(i-1, j);
             buffers.push_back(ptr);
             if(!ptr){
@@ -458,7 +458,7 @@ bool test_continuous_aligned_allocation()
                return false;
          }
          //Deallocate all
-         for(int k = (int)buffers.size(); k--;){
+         for(std::size_t k = buffers.size(); k--;){
             dlmalloc_free(buffers[k]);
          }
          buffers.clear();
@@ -485,7 +485,7 @@ bool test_many_equal_allocation()
       std::vector<void*> buffers2;
 
       //Allocate buffers with extra memory
-      for(int i = 0; i != NumIt; ++i){
+      for(std::size_t i = 0; i != NumIt; ++i){
          void *ptr = dlmalloc_malloc(i);
          if(!ptr)
             break;
@@ -496,7 +496,7 @@ bool test_many_equal_allocation()
 
       //Now deallocate the half of the blocks
       //so expand maybe can merge new free blocks
-      for(int i = 0, max = (int)buffers2.size()
+      for(std::size_t i = 0, max = buffers2.size()
          ;i < max
          ;++i){
          if(i%2){
@@ -509,7 +509,7 @@ bool test_many_equal_allocation()
          //return false;
 
       std::vector<void*> buffers;
-      for(int i = 0; i != NumIt/10; ++i){
+      for(std::size_t i = 0; i != NumIt/10; ++i){
          dlmalloc_memchain chain;
          BOOST_CONTAINER_MEMCHAIN_INIT(&chain);
          dlmalloc_multialloc_nodes((i+1)*2, i+1, BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain);
@@ -532,7 +532,7 @@ bool test_many_equal_allocation()
       switch(t){
          case DirectDeallocation:
          {
-            for(int j = 0, max = (int)buffers.size()
+            for(std::size_t j = 0, max = buffers.size()
                ;j < max
                ;++j){
                dlmalloc_free(buffers[j]);
@@ -541,7 +541,7 @@ bool test_many_equal_allocation()
          break;
          case InverseDeallocation:
          {
-            for(int j = (int)buffers.size()
+            for(std::size_t j = buffers.size()
                ;j--
                ;){
                dlmalloc_free(buffers[j]);
@@ -550,12 +550,12 @@ bool test_many_equal_allocation()
          break;
          case MixedDeallocation:
          {
-            for(int j = 0, max = (int)buffers.size()
+            for(std::size_t j = 0, max = buffers.size()
                ;j < max
                ;++j){
-               int pos = (j%4)*((int)buffers.size())/4;
+               std::size_t pos = (j%4u)*(buffers.size())/4u;
                dlmalloc_free(buffers[pos]);
-               buffers.erase(buffers.begin()+pos);
+               buffers.erase(buffers.begin()+(std::ptrdiff_t)pos);
             }
          }
          break;
@@ -566,12 +566,12 @@ bool test_many_equal_allocation()
       //Deallocate the rest of the blocks
 
       //Deallocate it in non sequential order
-      for(int j = 0, max = (int)buffers2.size()
+      for(std::size_t j = 0, max = buffers2.size()
          ;j < max
          ;++j){
-         int pos = (j%4)*((int)buffers2.size())/4;
+         std::size_t pos = (j%4u)*(buffers2.size())/4u;
          dlmalloc_free(buffers2[pos]);
-         buffers2.erase(buffers2.begin()+pos);
+         buffers2.erase(buffers2.begin()+(std::ptrdiff_t)pos);
       }
 
       //bool ok = free_memory == a.get_free_memory() &&
@@ -602,7 +602,7 @@ bool test_many_different_allocation()
       std::vector<void*> buffers2;
 
       //Allocate buffers with extra memory
-      for(int i = 0; i != NumIt; ++i){
+      for(std::size_t i = 0; i != NumIt; ++i){
          void *ptr = dlmalloc_malloc(i);
          if(!ptr)
             break;
@@ -611,7 +611,7 @@ bool test_many_different_allocation()
 
       //Now deallocate the half of the blocks
       //so expand maybe can merge new free blocks
-      for(int i = 0, max = (int)buffers2.size()
+      for(std::size_t i = 0, max = buffers2.size()
          ;i < max
          ;++i){
          if(i%2){
@@ -621,7 +621,7 @@ bool test_many_different_allocation()
       }
 
       std::vector<void*> buffers;
-      for(int i = 0; i != NumIt; ++i){
+      for(std::size_t i = 0; i != NumIt; ++i){
          dlmalloc_memchain chain;
          BOOST_CONTAINER_MEMCHAIN_INIT(&chain);
          dlmalloc_multialloc_arrays(ArraySize, requested_sizes, 1, BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain);
@@ -640,7 +640,7 @@ bool test_many_different_allocation()
       switch(t){
          case DirectDeallocation:
          {
-            for(int j = 0, max = (int)buffers.size()
+            for(std::size_t j = 0, max = buffers.size()
                ;j < max
                ;++j){
                dlmalloc_free(buffers[j]);
@@ -649,7 +649,7 @@ bool test_many_different_allocation()
          break;
          case InverseDeallocation:
          {
-            for(int j = (int)buffers.size()
+            for(std::size_t j = buffers.size()
                ;j--
                ;){
                dlmalloc_free(buffers[j]);
@@ -658,12 +658,12 @@ bool test_many_different_allocation()
          break;
          case MixedDeallocation:
          {
-            for(int j = 0, max = (int)buffers.size()
+            for(std::size_t j = 0, max = buffers.size()
                ;j < max
                ;++j){
-               int pos = (j%4)*((int)buffers.size())/4;
+               std::size_t pos = (j%4)*(buffers.size())/4;
                dlmalloc_free(buffers[pos]);
-               buffers.erase(buffers.begin()+pos);
+               buffers.erase(buffers.begin()+(std::ptrdiff_t)pos);
             }
          }
          break;
@@ -674,12 +674,12 @@ bool test_many_different_allocation()
       //Deallocate the rest of the blocks
 
       //Deallocate it in non sequential order
-      for(int j = 0, max = (int)buffers2.size()
+      for(std::size_t j = 0, max = buffers2.size()
          ;j < max
          ;++j){
-         int pos = (j%4)*((int)buffers2.size())/4;
+         std::size_t pos = (j%4u)*(buffers2.size())/4u;
          dlmalloc_free(buffers2[pos]);
-         buffers2.erase(buffers2.begin()+pos);
+         buffers2.erase(buffers2.begin()+(std::ptrdiff_t)pos);
       }
 
       //bool ok = free_memory == a.get_free_memory() &&
@@ -699,7 +699,7 @@ bool test_many_deallocation()
       requested_sizes[i] = 4*i;
    }
 
-   for(int i = 0; i != NumIt; ++i){
+   for(std::size_t i = 0; i != NumIt; ++i){
       dlmalloc_memchain chain;
       BOOST_CONTAINER_MEMCHAIN_INIT(&chain);
       dlmalloc_multialloc_arrays(ArraySize, requested_sizes, 1, BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain);
@@ -708,7 +708,7 @@ bool test_many_deallocation()
          return false;
       buffers.push_back(chain);
    }
-   for(int i = 0; i != NumIt; ++i){
+   for(std::size_t i = 0; i != NumIt; ++i){
       dlmalloc_multidealloc(&buffers[i]);
    }
    buffers.clear();
@@ -717,7 +717,7 @@ bool test_many_deallocation()
    if(!dlmalloc_all_deallocated())
       return false;
 
-   for(int i = 0; i != NumIt; ++i){
+   for(std::size_t i = 0; i != NumIt; ++i){
       dlmalloc_memchain chain;
       BOOST_CONTAINER_MEMCHAIN_INIT(&chain);
       dlmalloc_multialloc_nodes(ArraySize, i*4+1, BOOST_CONTAINER_DL_MULTIALLOC_DEFAULT_CONTIGUOUS, &chain);
@@ -726,7 +726,7 @@ bool test_many_deallocation()
          return false;
       buffers.push_back(chain);
    }
-   for(int i = 0; i != NumIt; ++i){
+   for(std::size_t i = 0; i != NumIt; ++i){
       dlmalloc_multidealloc(&buffers[i]);
    }
    buffers.clear();

test/check_equal_containers.hpp

@@ -69,11 +69,11 @@ bool CheckEqualContainers(const ContA &cont_a, const ContB &cont_b)
 
    typename ContA::const_iterator itcont_a(cont_a.begin()), itcont_a_end(cont_a.end());
    typename ContB::const_iterator itcont_b(cont_b.begin()), itcont_b_end(cont_b.end());;
-   typename ContB::size_type dist = (typename ContB::size_type)boost::container::iterator_distance(itcont_a, itcont_a_end);
+   typename ContB::size_type dist = boost::container::iterator_udistance(itcont_a, itcont_a_end);
    if(dist != cont_a.size()){
       return false;
    }
-   typename ContA::size_type dist2 = (typename ContA::size_type)boost::container::iterator_distance(itcont_b, itcont_b_end);
+   typename ContA::size_type dist2 = boost::container::iterator_udistance(itcont_b, itcont_b_end);
    if(dist2 != cont_b.size()){
       return false;
    }

test/container_common_tests.hpp

@@ -29,6 +29,8 @@ bool test_nth_index_of(Container &c)
    typename Container::iterator it;
    typename Container::const_iterator cit;
    typename Container::size_type sz, csz;
+   typedef typename Container::difference_type difference_type;
+
    //index 0
    it = c.nth(0);
    sz = c.index_of(it);
@@ -51,9 +53,9 @@ bool test_nth_index_of(Container &c)
    cit = (as_const)(c).nth(sz_div_2);
    csz = (as_const)(c).index_of(cit);
 
-   if(it != (c.begin()+sz_div_2))
+   if(it != (c.begin()+difference_type(sz_div_2)))
       return false;
-   if(cit != (c.cbegin()+sz_div_2))
+   if(cit != (c.cbegin()+difference_type(sz_div_2)))
       return false;
    if(sz != sz_div_2)
       return false;

test/deque_test.cpp

@@ -46,13 +46,13 @@ bool deque_copyable_only(V1 &cntdeque, V2 &stddeque, dtl::true_type)
 {
    typedef typename V1::value_type IntType;
    std::size_t size = cntdeque.size();
-   stddeque.insert(stddeque.end(), 50, 1);
+   stddeque.insert(stddeque.end(), 50u, 1);
-   cntdeque.insert(cntdeque.end(), 50, IntType(1));
+   cntdeque.insert(cntdeque.end(), 50u, IntType(1));
    if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
    {
       IntType move_me(1);
-      stddeque.insert(stddeque.begin()+size/2, 50, 1);
+      stddeque.insert(stddeque.begin()+std::ptrdiff_t(size)/2, 50u, 1);
-      cntdeque.insert(cntdeque.begin()+size/2, 50, boost::move(move_me));
+      cntdeque.insert(cntdeque.begin()+std::ptrdiff_t(size/2), 50u, boost::move(move_me));
       if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
    }
    {
@@ -65,28 +65,28 @@ bool deque_copyable_only(V1 &cntdeque, V2 &stddeque, dtl::true_type)
       IntType move_me(1);
       stddeque.clear();
       cntdeque.clear();
-      stddeque.insert(stddeque.begin(), 50, 1);
+      stddeque.insert(stddeque.begin(), 50u, 1);
-      cntdeque.insert(cntdeque.begin(), 50, boost::move(move_me));
+      cntdeque.insert(cntdeque.begin(), 50u, boost::move(move_me));
       if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
-      stddeque.insert(stddeque.begin()+20, 50, 1);
+      stddeque.insert(stddeque.begin()+20, 50u, 1);
-      cntdeque.insert(cntdeque.begin()+20, 50, boost::move(move_me));
+      cntdeque.insert(cntdeque.begin()+20, 50u, boost::move(move_me));
       if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
-      stddeque.insert(stddeque.begin()+20, 20, 1);
+      stddeque.insert(stddeque.begin()+20, 20u, 1);
-      cntdeque.insert(cntdeque.begin()+20, 20, boost::move(move_me));
+      cntdeque.insert(cntdeque.begin()+20, 20u, boost::move(move_me));
       if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
    }
    {
       IntType move_me(1);
       stddeque.clear();
       cntdeque.clear();
-      stddeque.insert(stddeque.end(), 50, 1);
+      stddeque.insert(stddeque.end(), 50u, 1);
-      cntdeque.insert(cntdeque.end(), 50, boost::move(move_me));
+      cntdeque.insert(cntdeque.end(), 50u, boost::move(move_me));
       if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
-      stddeque.insert(stddeque.end()-20, 50, 1);
+      stddeque.insert(stddeque.end()-20, 50u, 1);
-      cntdeque.insert(cntdeque.end()-20, 50, boost::move(move_me));
+      cntdeque.insert(cntdeque.end()-20, 50u, boost::move(move_me));
       if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
-      stddeque.insert(stddeque.end()-20, 20, 1);
+      stddeque.insert(stddeque.end()-20, 20u, 1);
-      cntdeque.insert(cntdeque.end()-20, 20, boost::move(move_me));
+      cntdeque.insert(cntdeque.end()-20, 20u, boost::move(move_me));
       if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
    }
 
@@ -204,10 +204,10 @@ bool do_test()
             aux_vect2[i] = i;
          }
 
-         cntdeque.insert(cntdeque.begin()+cntdeque.size()
+         cntdeque.insert(cntdeque.begin()+std::ptrdiff_t(cntdeque.size())
                            ,boost::make_move_iterator(&aux_vect[0])
                            ,boost::make_move_iterator(aux_vect + 50));
-         stddeque.insert(stddeque.begin()+stddeque.size(), aux_vect2, aux_vect2 + 50);
+         stddeque.insert(stddeque.begin()+std::ptrdiff_t(stddeque.size()), aux_vect2, aux_vect2 + 50);
          if(!test::CheckEqualContainers(cntdeque, stddeque)) return false;
 
          for(int i = 0, j = static_cast<int>(cntdeque.size()); i < j; ++i){

test/devector_test.cpp

@@ -1722,7 +1722,7 @@ template <class Devector> void test_reserve_front()
   Devector a;
 
   a.reserve_front(100);
-  for (unsigned i = 0; i < 100u; ++i)
+  for (int i = 0; i < 100; ++i)
   {
     a.push_front(value_type(i));
   }
@@ -1742,7 +1742,7 @@ template <class Devector> void test_reserve_back()
   Devector a;
   typedef typename Devector::value_type value_type;
   a.reserve_back(100);
-  for (unsigned i = 0; i < 100; ++i)
+  for (int i = 0; i < 100; ++i)
   {
     a.push_back(value_type(i));
   }
@@ -1760,19 +1760,20 @@ template <class Devector> void test_reserve_back()
 template <typename Devector>
 void test_shrink_to_fit_always()
 {
+   typedef typename Devector::value_type value_type;
    Devector a;
-   a.reserve(100);
+   a.reserve(100u);
 
-   a.push_back(1);
+   a.push_back(value_type(1));
-   a.push_back(2);
+   a.push_back(value_type(2));
-   a.push_back(3);
+   a.push_back(value_type(3));
 
    a.shrink_to_fit();
 
    boost::container::vector<unsigned> expected;
-   expected.push_back(1);
+   expected.push_back(1u);
-   expected.push_back(2);
+   expected.push_back(2u);
-   expected.push_back(3);
+   expected.push_back(3u);
    test_equal_range(a, expected);
 
    std::size_t exp_capacity = 3u;

test/expand_bwd_test_allocator.hpp

@@ -79,7 +79,7 @@ class expand_bwd_test_allocator
    {  typedef expand_bwd_test_allocator<T2>   other;   };
 
    //!Constructor from the segment manager. Never throws
-   expand_bwd_test_allocator(T *buffer, size_type sz, difference_type offset)
+   expand_bwd_test_allocator(T *buffer, size_type sz, size_type offset)
       : mp_buffer(buffer), m_size(sz)
       , m_offset(offset),  m_allocations(0){ }
 
@@ -171,7 +171,7 @@ class expand_bwd_test_allocator
 
    pointer           mp_buffer;
    size_type         m_size;
-   difference_type   m_offset;
+   size_type         m_offset;
    char              m_allocations;
 };
 

test/expand_bwd_test_template.hpp

@@ -89,7 +89,7 @@ bool test_insert_with_expand_bwd()
          std::vector<value_type> initial_data;
          initial_data.resize(InitialSize[iteration]);
          for(unsigned int i = 0; i < InitialSize[iteration]; ++i){
-            initial_data[i] = static_cast<value_type>(i);
+            initial_data[i] = static_cast<value_type>((int)i);
          }
 
          if(!life_count<value_type>::check(InitialSize[iteration]))
@@ -97,7 +97,7 @@ bool test_insert_with_expand_bwd()
          Vect data_to_insert;
          data_to_insert.resize(InsertSize[iteration]);
          for(unsigned int i = 0; i < InsertSize[iteration]; ++i){
-            data_to_insert[i] = static_cast<value_type>(-i);
+            data_to_insert[i] = static_cast<value_type>((int)-i);
          }
 
          if(!life_count<value_type>::check(InitialSize[iteration]+InsertSize[iteration]))
@@ -153,14 +153,14 @@ bool test_assign_with_expand_bwd()
       std::vector<value_type> initial_data;
       initial_data.resize(InitialSize[iteration]);
       for(unsigned int i = 0; i < InitialSize[iteration]; ++i){
-         initial_data[i] = static_cast<value_type>(i);
+         initial_data[i] = static_cast<value_type>((int)i);
       }
 
       //Create data to assign
       std::vector<value_type> data_to_insert;
       data_to_insert.resize(InsertSize[iteration]);
       for(unsigned int i = 0; i < InsertSize[iteration]; ++i){
-         data_to_insert[i] = static_cast<value_type>(-i);
+         data_to_insert[i] = static_cast<value_type>((int)-i);
       }
 
       //Insert initial data to the vector to test

test/insert_test.hpp

@@ -26,13 +26,13 @@ void
     BOOST_TEST(CheckEqualContainers(std_deque, seq_container));
 
     std_deque.insert(
-        std_deque.begin() + index
+        std_deque.begin() + std::ptrdiff_t(index)
       , input_deque.begin()
       , input_deque.end()
     );
 
     seq_container.insert(
-        seq_container.begin() + index
+        seq_container.begin() + std::ptrdiff_t(index)
       , input_deque.begin()
       , input_deque.end()
     );

test/list_test.hpp

@@ -22,6 +22,7 @@
 
 #include <list>
 #include <functional>   //std::greater
+#include <cstddef>   //std::size_t
 
 namespace boost{
 namespace container {
@@ -38,14 +39,14 @@ template<class V1, class V2>
 bool list_copyable_only(V1 &boostlist, V2 &stdlist, boost::container::dtl::true_type)
 {
    typedef typename V1::value_type IntType;
-   boostlist.insert(boostlist.end(), 50, IntType(1));
+   boostlist.insert(boostlist.end(), 50u, IntType(1));
-   stdlist.insert(stdlist.end(), 50, 1);
+   stdlist.insert(stdlist.end(), 50u, 1);
    if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
 
    {
       IntType move_me(1);
-      boostlist.insert(boostlist.begin(), 50, boost::move(move_me));
+      boostlist.insert(boostlist.begin(), 50u, boost::move(move_me));
-      stdlist.insert(stdlist.begin(), 50, 1);
+      stdlist.insert(stdlist.begin(), 50u, 1);
       if(!test::CheckEqualContainers(boostlist, stdlist)) return false;
    }
    {
@@ -104,14 +105,14 @@ template<bool DoublyLinked>
 struct list_push_data_function
 {
    template<class MyBoostList, class MyStdList>
-   static int execute(int max, MyBoostList &boostlist, MyStdList &stdlist)
+   static int execute(std::size_t max, MyBoostList &boostlist, MyStdList &stdlist)
    {
       typedef typename MyBoostList::value_type IntType;
-      for(int i = 0; i < max; ++i){
+      for(std::size_t i = 0; i < max; ++i){
-         IntType move_me(i);
+         IntType move_me((int)i);
          boostlist.push_back(boost::move(move_me));
-         stdlist.push_back(i);
+         stdlist.push_back((int)i);
-         boostlist.push_front(IntType(i));
+         boostlist.push_front(IntType(int(i)));
          stdlist.push_front(int(i));
       }
       if(!CheckEqualContainers(boostlist, stdlist))
@@ -124,14 +125,14 @@ template<>
 struct list_push_data_function<false>
 {
    template<class MyBoostList, class MyStdList>
-   static int execute(int max, MyBoostList &boostlist, MyStdList &stdlist)
+   static int execute(std::size_t max, MyBoostList &boostlist, MyStdList &stdlist)
    {
       typedef typename MyBoostList::value_type IntType;
-      for(int i = 0; i < max; ++i){
+      for(std::size_t i = 0; i < max; ++i){
-         IntType move_me(i);
+         IntType move_me((int)i);
          boostlist.push_front(boost::move(move_me));
-         stdlist.push_front(i);
+         stdlist.push_front((int)i);
-         boostlist.push_front(IntType(i));
+         boostlist.push_front(IntType(int(i)));
          stdlist.push_front(int(i));
       }
       if(!CheckEqualContainers(boostlist, stdlist))
@@ -171,35 +172,35 @@ int list_test (bool copied_allocators_equal = true)
 {
    typedef std::list<int> MyStdList;
    typedef typename MyBoostList::value_type IntType;
-   const int max = 100;
+   const std::size_t max = 100u;
    typedef list_push_data_function<DoublyLinked> push_data_t;
 
    {  //List(n)
-      ::boost::movelib::unique_ptr<MyBoostList> const pboostlist = ::boost::movelib::make_unique<MyBoostList>(100);
+      ::boost::movelib::unique_ptr<MyBoostList> const pboostlist = ::boost::movelib::make_unique<MyBoostList>(100u);
-      ::boost::movelib::unique_ptr<MyStdList> const pstdlist = ::boost::movelib::make_unique<MyStdList>(100);
+      ::boost::movelib::unique_ptr<MyStdList> const pstdlist = ::boost::movelib::make_unique<MyStdList>(100u);
       if(!test::CheckEqualContainers(*pboostlist, *pstdlist)) return 1;
    }
    {  //List(n, alloc)
-      ::boost::movelib::unique_ptr<MyBoostList> const pboostlist = ::boost::movelib::make_unique<MyBoostList>(100, typename MyBoostList::allocator_type());
+      ::boost::movelib::unique_ptr<MyBoostList> const pboostlist = ::boost::movelib::make_unique<MyBoostList>(100u, typename MyBoostList::allocator_type());
-      ::boost::movelib::unique_ptr<MyStdList> const pstdlist = ::boost::movelib::make_unique<MyStdList>(100);
+      ::boost::movelib::unique_ptr<MyStdList> const pstdlist = ::boost::movelib::make_unique<MyStdList>(100u);
       if(!test::CheckEqualContainers(*pboostlist, *pstdlist)) return 1;
    }
    {  //List(List &&)
-      ::boost::movelib::unique_ptr<MyStdList> const stdlistp = ::boost::movelib::make_unique<MyStdList>(100);
+      ::boost::movelib::unique_ptr<MyStdList> const stdlistp = ::boost::movelib::make_unique<MyStdList>(100u);
-      ::boost::movelib::unique_ptr<MyBoostList> const boostlistp = ::boost::movelib::make_unique<MyBoostList>(100);
+      ::boost::movelib::unique_ptr<MyBoostList> const boostlistp = ::boost::movelib::make_unique<MyBoostList>(100u);
       ::boost::movelib::unique_ptr<MyBoostList> const boostlistp2 = ::boost::movelib::make_unique<MyBoostList>(::boost::move(*boostlistp));
       if(!test::CheckEqualContainers(*boostlistp2, *stdlistp)) return 1;
    }
    {  //List(List &&, alloc)
-      ::boost::movelib::unique_ptr<MyStdList> const stdlistp = ::boost::movelib::make_unique<MyStdList>(100);
+      ::boost::movelib::unique_ptr<MyStdList> const stdlistp = ::boost::movelib::make_unique<MyStdList>(100u);
-      ::boost::movelib::unique_ptr<MyBoostList> const boostlistp = ::boost::movelib::make_unique<MyBoostList>(100);
+      ::boost::movelib::unique_ptr<MyBoostList> const boostlistp = ::boost::movelib::make_unique<MyBoostList>(100u);
       ::boost::movelib::unique_ptr<MyBoostList> const boostlistp2 = ::boost::movelib::make_unique<MyBoostList>
          (::boost::move(*boostlistp), typename MyBoostList::allocator_type());
       if(!test::CheckEqualContainers(*boostlistp2, *stdlistp)) return 1;
    }
    {  //List operator=(List &&)
-      ::boost::movelib::unique_ptr<MyStdList> const stdlistp = ::boost::movelib::make_unique<MyStdList>(100);
+      ::boost::movelib::unique_ptr<MyStdList> const stdlistp = ::boost::movelib::make_unique<MyStdList>(100u);
-      ::boost::movelib::unique_ptr<MyBoostList> const boostlistp = ::boost::movelib::make_unique<MyBoostList>(100);
+      ::boost::movelib::unique_ptr<MyBoostList> const boostlistp = ::boost::movelib::make_unique<MyBoostList>(100u);
       ::boost::movelib::unique_ptr<MyBoostList> const boostlistp2 = ::boost::movelib::make_unique<MyBoostList>();
       *boostlistp2 = ::boost::move(*boostlistp);
       if(!test::CheckEqualContainers(*boostlistp2, *stdlistp)) return 1;
@@ -324,10 +325,10 @@ int list_test (bool copied_allocators_equal = true)
          return 1;
    }
 
-   for(int i = 0; i < max; ++i){
+   for(std::size_t i = 0; i < max; ++i){
-      IntType new_int(i);
+      IntType new_int((int)i);
       boostlist.insert(boostlist.end(), boost::move(new_int));
-      stdlist.insert(stdlist.end(), i);
+      stdlist.insert(stdlist.end(), (int)i);
       if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
    }
    if(!test::CheckEqualContainers(boostlist, stdlist)) return 1;
@@ -362,7 +363,7 @@ int list_test (bool copied_allocators_equal = true)
       MyBoostList otherboostlist(boostlist.get_allocator());
       MyStdList otherstdlist;
 
-      int listsize = (int)boostlist.size();
+      std::size_t listsize = boostlist.size();
 
       if(push_data_t::execute(listsize, boostlist, stdlist)){
          return 1;
@@ -375,7 +376,7 @@ int list_test (bool copied_allocators_equal = true)
             return 1;
       }
 
-      listsize = (int)boostlist.size();
+      listsize = boostlist.size();
 
       if(push_data_t::execute(listsize, boostlist, stdlist)){
          return 1;

test/map_test.hpp

@@ -108,17 +108,19 @@ int map_test_copyable(boost::container::dtl::true_type)
    boostmap.clear();
    boostmultimap.clear();
    stdmultimap.clear();
+
    //Now try from convertible pair
    for(i = 0; i < MaxElem; ++i){
       {
-      boostmap.insert(std::pair<unsigned, unsigned>(i, i));
+      boostmap.insert(std::pair<signed short, signed short>((signed short)i, (signed short)i));
       stdmap.insert(StdPairType(i, i));
       }
       {
-      boostmultimap.insert(std::pair<unsigned, unsigned>(i, i));
+      boostmultimap.insert(std::pair<signed short, signed short>((signed short)i, (signed short)i));
       stdmultimap.insert(StdPairType(i, i));
       }
    }
+
    if(!CheckEqualContainers(boostmap, stdmap)) return 1;
    if(!CheckEqualContainers(boostmultimap, stdmultimap)) return 1;
 
@@ -692,8 +694,8 @@ int map_test_insert2(MyBoostMap &boostmap, MyStdMap &stdmap, MyBoostMultiMap &bo
          std::pair<typename MyStdMultiMap::iterator, typename MyStdMultiMap::iterator>   sret =
             stdmultimap.equal_range(stdmultimap.begin()->first);
 
-         if( boost::container::iterator_distance(bret.first, bret.second) !=
+         if( boost::container::iterator_udistance(bret.first, bret.second) !=
-               boost::container::iterator_distance(sret.first, sret.second) ){
+               boost::container::iterator_udistance(sret.first, sret.second) ){
             return 1;
          }
       }

test/static_vector_test.cpp

@@ -198,7 +198,7 @@ void test_pop_back_nd()
 template <typename It1, typename It2>
 void test_compare_ranges(It1 first1, It1 last1, It2 first2, It2 last2)
 {
-   BOOST_TEST(boost::container::iterator_distance(first1, last1) == boost::container::iterator_distance(first2, last2));
+   BOOST_TEST(boost::container::iterator_udistance(first1, last1) == boost::container::iterator_udistance(first2, last2));
    for ( ; first1 != last1 && first2 != last2 ; ++first1, ++first2 )
       BOOST_TEST(*first1 == *first2);
 }
@@ -290,6 +290,7 @@ void test_erase_nd()
 {
    static_vector<T, N> s;
    typedef typename static_vector<T, N>::iterator It;
+   typedef typename static_vector<T, N>::difference_type dif_t;
 
    for ( size_t i = 0 ; i < N ; ++i )
       s.push_back(T((int)i));
@@ -299,8 +300,8 @@ void test_erase_nd()
       for ( size_t i = 0 ; i < N ; ++i )
       {
           static_vector<T, N> s1(s);
-          It it = s1.erase(s1.begin() + i);
+          It it = s1.erase(s1.begin() + dif_t(i));
-          BOOST_TEST(s1.begin() + i == it);
+          BOOST_TEST(s1.begin() + dif_t(i) == it);
           BOOST_TEST(s1.size() == N - 1);
           for ( size_t j = 0 ; j < i ; ++j )
               BOOST_TEST(s1[j] == T((int)j));
@@ -315,8 +316,8 @@ void test_erase_nd()
       {
           static_vector<T, N> s1(s);
           size_t removed = i + n < N ? n : N - i;
-          It it = s1.erase(s1.begin() + i, s1.begin() + i + removed);
+          It it = s1.erase(s1.begin() + dif_t(i), s1.begin() + dif_t(i + removed));
-          BOOST_TEST(s1.begin() + i == it);
+          BOOST_TEST(s1.begin() + dif_t(i) == it);
           BOOST_TEST(s1.size() == N - removed);
           for ( size_t j = 0 ; j < i ; ++j )
               BOOST_TEST(s1[j] == T((int)j));
@@ -330,18 +331,19 @@ template <typename T, size_t N, typename SV, typename C>
 void test_insert(SV const& s, C const& c)
 {
    size_t h = N/2;
-   size_t n = size_t(h/1.5f);
+   size_t n = size_t(float(h)/1.5f);
+   typedef typename static_vector<T, N>::difference_type dif_t;
 
    for ( size_t i = 0 ; i <= h ; ++i )
    {
       static_vector<T, N> s1(s);
 
       typename C::const_iterator it = c.begin();
-      boost::container::iterator_advance(it, n);
+      boost::container::iterator_uadvance(it, n);
       typename static_vector<T, N>::iterator
-          it1 = s1.insert(s1.begin() + i, c.begin(), it);
+          it1 = s1.insert(s1.begin() + dif_t(i), c.begin(), it);
 
-      BOOST_TEST(s1.begin() + i == it1);
+      BOOST_TEST(s1.begin() + dif_t(i) == it1);
       BOOST_TEST(s1.size() == h+n);
       for ( size_t j = 0 ; j < i ; ++j )
           BOOST_TEST(s1[j] == T((int)j));
@@ -362,6 +364,7 @@ void test_insert_nd(T const& val)
    list<T> l;
 
    typedef typename static_vector<T, N>::iterator It;
+   typedef typename static_vector<T, N>::difference_type dif_t;
 
    for ( size_t i = 0 ; i < h ; ++i )
    {
@@ -376,8 +379,8 @@ void test_insert_nd(T const& val)
       for ( size_t i = 0 ; i <= h ; ++i )
       {
           static_vector<T, N> s1(s);
-          It it = s1.insert(s1.begin() + i, val);
+          It it = s1.insert(s1.begin() + dif_t(i), val);
-          BOOST_TEST(s1.begin() + i == it);
+          BOOST_TEST(s1.begin() + dif_t(i) == it);
           BOOST_TEST(s1.size() == h+1);
           for ( size_t j = 0 ; j < i ; ++j )
               BOOST_TEST(s1[j] == T((int)j));
@@ -388,12 +391,12 @@ void test_insert_nd(T const& val)
    }
    // insert(pos, n, val)
    {
-      size_t n = size_t(h/1.5f);
+      size_t n = size_t(float(h)/1.5f);
       for ( size_t i = 0 ; i <= h ; ++i )
       {
           static_vector<T, N> s1(s);
-          It it = s1.insert(s1.begin() + i, n, val);
+          It it = s1.insert(s1.begin() + dif_t(i), n, val);
-          BOOST_TEST(s1.begin() + i == it);
+          BOOST_TEST(s1.begin() + dif_t(i) == it);
           BOOST_TEST(s1.size() == h+n);
           for ( size_t j = 0 ; j < i ; ++j )
               BOOST_TEST(s1[j] == T((int)j));
@@ -571,18 +574,19 @@ void test_emplace_2p()
    {
       static_vector<T, N> v;
 
-      for (int i = 0 ; i < int(N) ; ++i )
+      for (int i = 0 ; i < (int)N ; ++i )
           v.emplace_back(i, 100 + i);
       BOOST_TEST(v.size() == N);
       BOOST_TEST_THROWS(v.emplace_back((int)N, 100 + (int)N), bad_alloc_t);
       BOOST_TEST(v.size() == N);
-      for (int i = 0 ; i < int(N) ; ++i )
+      for (int i = 0 ; i < (int)N ; ++i )
-          BOOST_TEST(v[i] == T(i, 100 + i));
+          BOOST_TEST(v[std::size_t(i)] == T(i, 100 + i));
    }
 
    // emplace(pos, int, int)
    {
       typedef typename static_vector<T, N>::iterator It;
+      typedef typename static_vector<T, N>::difference_type dif_t;
 
       int h = N / 2;
 
@@ -593,14 +597,14 @@ void test_emplace_2p()
       for ( int i = 0 ; i <= h ; ++i )
       {
           static_vector<T, N> vv(v);
-          It it = vv.emplace(vv.begin() + i, i+100, i+200);
+          It it = vv.emplace(vv.begin() + dif_t(i), i+100, i+200);
-          BOOST_TEST(vv.begin() + i == it);
+          BOOST_TEST(vv.begin() + dif_t(i) == it);
           BOOST_TEST(vv.size() == size_t(h+1));
           for ( int j = 0 ; j < i ; ++j )
-              BOOST_TEST(vv[j] == T(j, j+100));
+              BOOST_TEST(vv[std::size_t(j)] == T(j, j+100));
-          BOOST_TEST(vv[i] == T(i+100, i+200));
+          BOOST_TEST(vv[std::size_t(i)] == T(i+100, i+200));
           for ( int j = 0 ; j < h-i ; ++j )
-              BOOST_TEST(vv[j+i+1] == T(j+i, j+i+100));
+              BOOST_TEST(vv[std::size_t(j+i+1)] == T(j+i, j+i+100));
       }
    }
 }

test/string_test.cpp

@@ -97,6 +97,18 @@ struct string_literals<char>
    {
       std::sprintf(buf, "%i", number);
    }
+   static void sprintf_number(char *buf, unsigned number)
+   {
+      std::sprintf(buf, "%u", number);
+   }
+   static void sprintf_number(char *buf, long number)
+   {
+      std::sprintf(buf, "%li", number);
+   }
+   static void sprintf_number(char *buf, unsigned long number)
+   {
+      std::sprintf(buf, "%lu", number);
+   }
 };
 
 template<>
@@ -119,7 +131,7 @@ struct string_literals<wchar_t>
       wchar_t *buf = buffer;
 
       while(1){
-         int rem = number % 10;
+         unsigned rem = number % 10;
          number  = number / 10;
 
          *buf = digits[rem];
@@ -141,7 +153,7 @@ int string_test()
    typedef basic_string<CharType> BoostString;
    typedef vector<BoostString> BoostStringVector;
 
-   const int MaxSize = 100;
+   const std::size_t MaxSize = 100;
 
    {
       BoostStringVector *boostStringVect = new BoostStringVector;
@@ -152,7 +164,7 @@ int string_test()
       CharType buffer [20];
 
       //First, push back
-      for(int i = 0; i < MaxSize; ++i){
+      for(std::size_t i = 0; i < MaxSize; ++i){
          auxBoostString = string_literals<CharType>::String();
          auxStdString = string_literals<CharType>::String();
          string_literals<CharType>::sprintf_number(buffer, i);
@@ -171,7 +183,7 @@ int string_test()
       }
 
       //Now push back moving
-      for(int i = 0; i < MaxSize; ++i){
+      for(std::size_t i = 0; i < MaxSize; ++i){
          auxBoostString = string_literals<CharType>::String();
          auxStdString = string_literals<CharType>::String();
          string_literals<CharType>::sprintf_number(buffer, i);
@@ -186,7 +198,7 @@ int string_test()
       }
 
       //push front
-      for(int i = 0; i < MaxSize; ++i){
+      for(std::size_t i = 0; i < MaxSize; ++i){
          auxBoostString = string_literals<CharType>::String();
          auxStdString = string_literals<CharType>::String();
          string_literals<CharType>::sprintf_number(buffer, i);
@@ -201,7 +213,7 @@ int string_test()
       }
 
       //Now push front moving
-      for(int i = 0; i < MaxSize; ++i){
+      for(std::size_t i = 0; i < MaxSize; ++i){
          auxBoostString = string_literals<CharType>::String();
          auxStdString = string_literals<CharType>::String();
          string_literals<CharType>::sprintf_number(buffer, i);
@@ -285,10 +297,10 @@ int string_test()
       if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
 
       const CharType *prefix    = string_literals<CharType>::Prefix();
-      const int  prefix_size    = std::char_traits<CharType>::length(prefix);
+      const std::size_t  prefix_size    = std::char_traits<CharType>::length(prefix);
       const CharType *sufix      = string_literals<CharType>::Suffix();
 
-      for(int i = 0; i < MaxSize; ++i){
+      for(std::size_t i = 0; i < MaxSize; ++i){
          (*boostStringVect)[i].append(sufix);
          (*stdStringVect)[i].append(sufix);
          (*boostStringVect)[i].insert((*boostStringVect)[i].begin(),
@@ -299,28 +311,28 @@ int string_test()
 
       if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
 
-      for(int i = 0; i < MaxSize; ++i){
+      for(std::size_t i = 0; i < MaxSize; ++i){
          std::reverse((*boostStringVect)[i].begin(), (*boostStringVect)[i].end());
          std::reverse((*stdStringVect)[i].begin(), (*stdStringVect)[i].end());
       }
 
       if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
 
-      for(int i = 0; i < MaxSize; ++i){
+      for(std::size_t i = 0; i < MaxSize; ++i){
          std::reverse((*boostStringVect)[i].begin(), (*boostStringVect)[i].end());
          std::reverse((*stdStringVect)[i].begin(), (*stdStringVect)[i].end());
       }
 
       if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
 
-      for(int i = 0; i < MaxSize; ++i){
+      for(std::size_t i = 0; i < MaxSize; ++i){
          std::sort(boostStringVect->begin(), boostStringVect->end());
          std::sort(stdStringVect->begin(), stdStringVect->end());
       }
 
       if(!CheckEqualStringVector(boostStringVect, stdStringVect)) return 1;
 
-      for(int i = 0; i < MaxSize; ++i){
+      for(std::size_t i = 0; i < MaxSize; ++i){
          (*boostStringVect)[i].replace((*boostStringVect)[i].begin(),
                                     (*boostStringVect)[i].end(),
                                     string_literals<CharType>::String());

test/test_util.hpp

@@ -128,7 +128,7 @@ void test_equal_range(const C& a, std::initializer_list<unsigned> il)
 
   for (auto&& elem : il)
   {
-    b.emplace_back(elem);
+    b.emplace_back((int)elem);
   }
 
   test_equal_range(a, b);

test/vector_test.hpp

@@ -99,15 +99,16 @@ template<class MyBoostVector, class MyStdVector>
 bool vector_copyable_only(MyBoostVector &boostvector, MyStdVector &stdvector, boost::container::dtl::true_type)
 {
    typedef typename MyBoostVector::value_type IntType;
+   typedef typename MyBoostVector::difference_type difference_type;
    std::size_t size = boostvector.size();
-   boostvector.insert(boostvector.end(), 50, IntType(1));
+   boostvector.insert(boostvector.end(), 50u, IntType(1));
-   stdvector.insert(stdvector.end(), 50, 1);
+   stdvector.insert(stdvector.end(), 50u, 1);
    if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
 
    {
       IntType move_me(1);
-      boostvector.insert(boostvector.begin()+size/2, 50, boost::move(move_me));
+      boostvector.insert(boostvector.begin()+difference_type(size/2), 50u, boost::move(move_me));
-      stdvector.insert(stdvector.begin()+size/2, 50, 1);
+      stdvector.insert(stdvector.begin()+difference_type(size/2), 50u, 1);
       if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
    }
    {
@@ -164,32 +165,32 @@ bool vector_copyable_only(MyBoostVector &boostvector, MyStdVector &stdvector, bo
    }
    {  //Vector(n, T)
       ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
-         ::boost::movelib::make_unique<MyStdVector>(100, int(5));
+         ::boost::movelib::make_unique<MyStdVector>(100u, int(5));
       ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
-         ::boost::movelib::make_unique<MyBoostVector>(100, IntType(5));
+         ::boost::movelib::make_unique<MyBoostVector>(100u, IntType(5));
       if(!test::CheckEqualContainers(*boostvectorp, *stdvectorp)) return 1;
    }
    {  //Vector(n, T, alloc)
       ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
-         ::boost::movelib::make_unique<MyStdVector>(100, int(5));
+         ::boost::movelib::make_unique<MyStdVector>(100u, int(5));
       ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
-         ::boost::movelib::make_unique<MyBoostVector>(100, IntType(5), typename MyBoostVector::allocator_type());
+         ::boost::movelib::make_unique<MyBoostVector>(100u, IntType(5), typename MyBoostVector::allocator_type());
       if(!test::CheckEqualContainers(*boostvectorp, *stdvectorp)) return 1;
    }
    {  //Vector(It, It)
       ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
-         ::boost::movelib::make_unique<MyStdVector>(100);
+         ::boost::movelib::make_unique<MyStdVector>(100u);
       ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
-         ::boost::movelib::make_unique<MyBoostVector>(100);
+         ::boost::movelib::make_unique<MyBoostVector>(100u);
       ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp2 =
          ::boost::movelib::make_unique<MyBoostVector>(boostvectorp->begin(), boostvectorp->end());
       if(!test::CheckEqualContainers(*boostvectorp2, *stdvectorp)) return 1;
    }
    {  //Vector(It, It, alloc)
       ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
-         ::boost::movelib::make_unique<MyStdVector>(100);
+         ::boost::movelib::make_unique<MyStdVector>(100u);
       ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
-         ::boost::movelib::make_unique<MyBoostVector>(100);
+         ::boost::movelib::make_unique<MyBoostVector>(100u);
       ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp2 =
          ::boost::movelib::make_unique<MyBoostVector>(boostvectorp->begin(), boostvectorp->end(), typename MyBoostVector::allocator_type());
       if(!test::CheckEqualContainers(*boostvectorp2, *stdvectorp)) return 1;
@@ -199,8 +200,8 @@ bool vector_copyable_only(MyBoostVector &boostvector, MyStdVector &stdvector, bo
          ::boost::movelib::make_unique<MyStdVector>();
       ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
          ::boost::movelib::make_unique<MyBoostVector>();
-      stdvectorp->resize(100, int(9));
+      stdvectorp->resize(100u, int(9));
-      boostvectorp->resize(100, IntType(9));
+      boostvectorp->resize(100u, IntType(9));
       if(!test::CheckEqualContainers(*boostvectorp, *stdvectorp)) return 1;
    }
    //operator=
@@ -215,8 +216,8 @@ bool vector_copyable_only(MyBoostVector &boostvector, MyStdVector &stdvector, bo
       if(!test::CheckEqualContainers(bcopy2, scopy2)) return false;
 
       //Assignment from a smaller vector
-      bcopy2.erase(bcopy2.begin() + bcopy2.size()/2, bcopy2.end());
+      bcopy2.erase(bcopy2.begin() + difference_type(bcopy2.size()/2), bcopy2.end());
-      scopy2.erase(scopy2.begin() + scopy2.size()/2, scopy2.end());
+      scopy2.erase(scopy2.begin() + difference_type(scopy2.size()/2), scopy2.end());
       bcopy = bcopy2;
       scopy = scopy2;
       if(!test::CheckEqualContainers(bcopy, scopy)) return false;
@@ -227,8 +228,8 @@ bool vector_copyable_only(MyBoostVector &boostvector, MyStdVector &stdvector, bo
       if(!test::CheckEqualContainers(bcopy2, scopy2)) return false;
 
       //Assignment from bigger vector with no capacity
-      bcopy2.erase(bcopy2.begin() + bcopy2.size()/2, bcopy2.end());
+      bcopy2.erase(bcopy2.begin() + difference_type(bcopy2.size()/2), bcopy2.end());
-      scopy2.erase(scopy2.begin() + scopy2.size()/2, scopy2.end());
+      scopy2.erase(scopy2.begin() + difference_type(scopy2.size()/2), scopy2.end());
       bcopy2.shrink_to_fit();
       MyStdVector(scopy2).swap(scopy2);
 
@@ -250,6 +251,7 @@ int vector_test()
 {
    typedef std::vector<int>                     MyStdVector;
    typedef typename MyBoostVector::value_type   IntType;
+   typedef typename MyBoostVector::difference_type difference_type;
    const int max = 100;
 
    if(!test_range_insertion<MyBoostVector>()){
@@ -257,32 +259,32 @@ int vector_test()
    }
    {  //Vector(n)
       ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
-         ::boost::movelib::make_unique<MyBoostVector>(100);
+         ::boost::movelib::make_unique<MyBoostVector>(100u);
       ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
-         ::boost::movelib::make_unique<MyStdVector>(100);
+         ::boost::movelib::make_unique<MyStdVector>(100u);
       if(!test::CheckEqualContainers(*boostvectorp, *stdvectorp)) return 1;
    }
    {  //Vector(n, alloc)
       ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
-         ::boost::movelib::make_unique<MyBoostVector>(100, typename MyBoostVector::allocator_type());
+         ::boost::movelib::make_unique<MyBoostVector>(100u, typename MyBoostVector::allocator_type());
       ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
-         ::boost::movelib::make_unique<MyStdVector>(100);
+         ::boost::movelib::make_unique<MyStdVector>(100u);
       if(!test::CheckEqualContainers(*boostvectorp, *stdvectorp)) return 1;
    }
    {  //Vector(Vector &&)
       ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
-         ::boost::movelib::make_unique<MyStdVector>(100);
+         ::boost::movelib::make_unique<MyStdVector>(100u);
       ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
-         ::boost::movelib::make_unique<MyBoostVector>(100);
+         ::boost::movelib::make_unique<MyBoostVector>(100u);
       ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp2 =
          ::boost::movelib::make_unique<MyBoostVector>(::boost::move(*boostvectorp));
       if(!test::CheckEqualContainers(*boostvectorp2, *stdvectorp)) return 1;
    }
    {  //Vector(Vector &&, alloc)
       ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
-         ::boost::movelib::make_unique<MyStdVector>(100);
+         ::boost::movelib::make_unique<MyStdVector>(100u);
       ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
-         ::boost::movelib::make_unique<MyBoostVector>(100);
+         ::boost::movelib::make_unique<MyBoostVector>(100u);
       ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp2 =
          ::boost::movelib::make_unique<MyBoostVector>
             (::boost::move(*boostvectorp), typename MyBoostVector::allocator_type());
@@ -290,9 +292,9 @@ int vector_test()
    }
    {  //Vector operator=(Vector &&)
       ::boost::movelib::unique_ptr<MyStdVector> const stdvectorp =
-         ::boost::movelib::make_unique<MyStdVector>(100);
+         ::boost::movelib::make_unique<MyStdVector>(100u);
       ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp =
-         ::boost::movelib::make_unique<MyBoostVector>(100);
+         ::boost::movelib::make_unique<MyBoostVector>(100u);
       ::boost::movelib::unique_ptr<MyBoostVector> const boostvectorp2 =
          ::boost::movelib::make_unique<MyBoostVector>();
       *boostvectorp2 = ::boost::move(*boostvectorp);
@@ -305,8 +307,8 @@ int vector_test()
       MyBoostVector & boostvector = *boostvectorp;
       MyStdVector & stdvector = *stdvectorp;
 
-      boostvector.resize(100);
+      boostvector.resize(100u);
-      stdvector.resize(100);
+      stdvector.resize(100u);
       if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
 
       boostvector.resize(200);
@@ -358,7 +360,7 @@ int vector_test()
             boostvector.insert(boostvector.end()
                            ,boost::make_move_iterator(&aux_vect[0])
                            ,boost::make_move_iterator(aux_vect + 50));
-         if(std::size_t(boost::container::iterator_distance(insert_it, boostvector.end())) != 50) return 1;
+         if(boost::container::iterator_udistance(insert_it, boostvector.end()) != 50) return 1;
          stdvector.insert(stdvector.end(), aux_vect2, aux_vect2 + 50);
          if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
 
@@ -369,8 +371,8 @@ int vector_test()
          if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
       }
       {
-         boostvector.resize(100);
+         boostvector.resize(100u);
-         stdvector.resize(100);
+         stdvector.resize(100u);
          if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
 
          IntType aux_vect[50];
@@ -384,11 +386,11 @@ int vector_test()
          }
          typename MyBoostVector::size_type old_size = boostvector.size();
          typename MyBoostVector::iterator insert_it =
-            boostvector.insert(boostvector.begin() + old_size/2
+            boostvector.insert(boostvector.begin() + difference_type(old_size/2)
                            ,boost::make_move_iterator(&aux_vect[0])
                            ,boost::make_move_iterator(aux_vect + 50));
-         if(boostvector.begin() + old_size/2 != insert_it) return 1;
+         if(boostvector.begin() + difference_type(old_size/2) != insert_it) return 1;
-         stdvector.insert(stdvector.begin() + old_size/2, aux_vect2, aux_vect2 + 50);
+         stdvector.insert(stdvector.begin() + difference_type(old_size/2), aux_vect2, aux_vect2 + 50);
          if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
 
          for(int i = 0; i < 50; ++i){
@@ -401,12 +403,12 @@ int vector_test()
          }
          old_size = boostvector.size();
          //Now try with input iterators instead
-         insert_it = boostvector.insert(boostvector.begin() + old_size/2
+         insert_it = boostvector.insert(boostvector.begin() + difference_type(old_size/2)
                            ,boost::make_move_iterator(make_input_from_forward_iterator(&aux_vect[0]))
                            ,boost::make_move_iterator(make_input_from_forward_iterator(aux_vect + 50))
                         );
-         if(boostvector.begin() + old_size/2 != insert_it) return 1;
+         if(boostvector.begin() + difference_type(old_size/2) != insert_it) return 1;
-         stdvector.insert(stdvector.begin() + old_size/2, aux_vect2, aux_vect2 + 50);
+         stdvector.insert(stdvector.begin() + difference_type(old_size/2), aux_vect2, aux_vect2 + 50);
          if(!test::CheckEqualContainers(boostvector, stdvector)) return 1;
       }
 
@@ -505,7 +507,7 @@ int vector_test()
       MyStdVector(stdvector).swap(stdvector);
       if(!test::CheckEqualContainers(boostvector, stdvector)) return false;
 
-      boostvector.resize(100);
+      boostvector.resize(100u);
       if(!test_nth_index_of(boostvector))
          return 1;