自定義分配器只編譯在Release模式在VS 2015年

Question

我寫了一個簡單的虛擬分配的vector<>，這樣我可以使用vector<>作爲堆棧數組的包裝，像這樣：只有在調試

#include <vector> 
#include "stdio.h" 
#include "stack_allocator.h" 

using namespace std; 

int main() { 
    int buffer[100]; 
    vector<int, StackAllocator<int>> v((StackAllocator<int>(buffer, 100))); 
    v.push_back(2); 
    printf("%d", v[0]); 
    v.pop_back(); 
} 

然而，模式在VS2015，我得到以下編譯器錯誤：

'std::StackAllocator<T2, std::allocator<T>>::StackAllocator(std::StackAllocator<T, std::allocator<T>> &&)': 
    cannot convert argument 1 from 
     'std::_Wrap_alloc<std::StackAllocator<int,std::allocator<T>>>' 
    to 
     'const std::allocator<T>&' 
in "c:\program files (x86)\microsoft visual studio 14.0\vc\include\xmemory0" at line 952 

編譯和執行工作按預期在Release模式，雖然。

這裏是stack_allocator.h：

#pragma once 

#include <functional> 

namespace std { 
    template <typename T, typename Allocator = allocator<T>> 
    class StackAllocator { 
    public: 
     typedef typename allocator_traits<Allocator>::value_type value_type; 
     typedef typename allocator_traits<Allocator>::pointer pointer; 
     typedef typename allocator_traits<Allocator>::const_pointer const_pointer; 
     typedef typename allocator_traits<Allocator>::size_type size_type; 
     typedef typename allocator_traits<Allocator>::difference_type difference_type; 
     typedef typename allocator_traits<Allocator>::const_void_pointer const_void_pointer; 
     typedef typename Allocator::reference reference; 
     typedef typename Allocator::const_reference const_reference; 

     template<typename T2> 
     struct rebind { 
      typedef StackAllocator<T2> other; 
     }; 

    private: 
     size_t m_size; 
     Allocator m_allocator; 
     pointer m_begin; 
     pointer m_end; 
     pointer m_stack_pointer; 

     bool pointer_to_internal_buffer(const_pointer p) const { 
      return (!(less<const_pointer>()(p, m_begin)) && (less<const_pointer>()(p, m_end))); 
     } 

    public: 
     StackAllocator(const Allocator& alloc = Allocator()) noexcept : 
      m_size(0), 
      m_allocator(alloc), 
      m_begin(nullptr), 
      m_end(nullptr), 
      m_stack_pointer(nullptr) { 
     } 

     StackAllocator(pointer buffer, size_t size, const Allocator& alloc = Allocator()) noexcept : 
      m_size(size), 
      m_allocator(alloc), 
      m_begin(buffer), 
      m_end(buffer + size), 
      m_stack_pointer(buffer) { 
     } 

     template <typename T2> 
     StackAllocator(const StackAllocator<T2, Allocator>& other) noexcept : 
      m_size(other.m_size), 
      m_allocator(other.m_allocator), 
      m_begin(other.m_begin), 
      m_end(other.m_end), 
      m_stack_pointer(other.m_stack_pointer) { 
     } 

     pointer allocate(size_type n, const_void_pointer hint = const_void_pointer()) { 
      if (n <= size_type(distance(m_stack_pointer, m_end))) { 
       pointer result = m_stack_pointer; 
       m_stack_pointer += n; 
       return result; 
      } 
      else 
       return m_allocator.allocate(n, hint); 
     } 

     void deallocate(pointer p, size_type n) { 
      if (pointer_to_internal_buffer(p)) 
       m_stack_pointer -= n; 
      else 
       m_allocator.deallocate(p, n); 
     } 

     size_type capacity() const noexcept { 
      return m_size; 
     } 

     size_type max_size() const noexcept { 
      return m_size; 
     } 

     pointer address(reference x) const noexcept { 
      if (pointer_to_internal_buffer(addressof(x))) 
       return addressof(x); 
      else 
       return m_allocator.address(x); 
     } 

     const_pointer address(const_reference x) const noexcept { 
      if (pointer_to_internal_buffer(addressof(x))) 
       return addressof(x); 
      else 
       return m_allocator.address(x); 
     } 

     pointer buffer() const noexcept { 
      return m_begin; 
     } 

     template <typename T2, typename... Args> 
     void construct(T2* p, Args&&... args) { 
      m_allocator.construct(p, forward<Args>(args)...); 
     } 

     template <typename T2> 
     void destroy(T2* p) { 
      m_allocator.destroy(p); 
     } 

     template <typename T2> 
     bool operator==(const StackAllocator<T2, Allocator>& other) const noexcept { 
      return buffer() == other.buffer(); 
     } 

     template <typename T2> 
     bool operator!=(const StackAllocator<T2, Allocator>& other) const noexcept { 
      return buffer() != other.buffer(); 
     } 
    }; 
} 

任何人有一個線索，爲什麼這個錯誤發生？我如何解決它？

Answer 1

你rebind被打破，它應該是：

template<typename T2> 
    struct rebind { 
     using Alloc2 
      = typename allocator_traits<Allocator>::rebind_alloc<T2>; 
     using other = StackAllocator<T2, Alloc2>; 
    }; 

否則總是重新綁定使用std::allocator<T2>不是與當前Allocator參數創造的東西。

例如如果您實例化StackAllocator<int, SomeAlloc<int>，然後將其重新綁定到long，則會得到StackAllocator<long, std::allocator<long>>，這是完全不同的類型。

我認爲VC++調試模式是通過重新綁定你的創建某種包裝分配器，它失敗了，因爲你的破損rebind。

而且，這些線是一個問題：

typedef typename Allocator::reference reference; 
    typedef typename Allocator::const_reference const_reference; 

各類會議分配器要求不必有reference和const_reference所以通過將這些類型定義您確保分配只能與分配器的一個子集工作。如果你認爲你需要他們，只是定義它們以同樣的方式std::allocator不：

typedef value_type& reference; 
    typedef const value_type& const_reference;