Question

我已经编写了一个自定义分配，我正在使用std :: vector。代码在调试模式下编译并运行，但无法在发布模式下编译并出现奇怪的错误。

这是我的分配器：

template< class T >
class AllocPowOf2
{
public:

   typedef size_t     size_type;
   typedef ptrdiff_t  difference_type;
   typedef T *        pointer;
   typedef const T *  const_pointer;
   typedef T &        reference;
   typedef const T &  const_reference;
   typedef T          value_type;

private:

   size_type m_nMinNbBytes;

public:

   template< class U >
   struct rebind
   {
       typedef AllocPowOf2< U > other;
   };

   inline pointer address( reference value ) const
   {
       return & value;
   }

   inline const_pointer address( const_reference value ) const
   {
       return & value;
   }

   inline AllocPowOf2( size_type nMinNbBytes = 32 )
    : m_nMinNbBytes( nMinNbBytes ) { }

   inline AllocPowOf2( const AllocPowOf2 & oAlloc )
    : m_nMinNbBytes( oAlloc.m_nMinNbBytes ) { }

   template< class U >
   inline AllocPowOf2( const AllocPowOf2< U > & oAlloc )
    : m_nMinNbBytes( oAlloc.m_nMinNbBytes ) { }

   inline ~AllocPowOf2() { }

   inline bool operator != ( const AllocPowOf2< T > & oAlloc )
   {
      return m_nMinNbBytes != oAlloc.m_nMinNbBytes;
   }

   inline size_type max_size() const
   {
       return size_type( -1 ) / sizeof( value_type );
   }

   static size_type OptimizeNbBytes( size_type nNbBytes, size_type nMin )
   {
      if( nNbBytes < nMin )
      {
         nNbBytes = nMin;
      }
      else
      {
         size_type j = nNbBytes;

         j |= (j >>  1);
         j |= (j >>  2);
         j |= (j >>  4);
         j |= (j >>  8);

#if ENV_32BITS || ENV_64BITS
         j |= (j >> 16);
#endif
#if ENV_64BITS
         j |= (j >> 32);
#endif
         ++j; // Least power of two greater than nNbBytes and nMin

         if( j > nNbBytes )
         {
            nNbBytes = j;
         }
      }
      return nNbBytes;
   }

   pointer allocate( size_type nNum )
   {
      return new value_type[ OptimizeNbBytes( nNum * sizeof( value_type ), 32 ) ]; // ERROR HERE, line 97
   }

   void construct( pointer p, const value_type & value )
   {
      new ((void *) p) value_type( value );
   }

   void destroy( pointer p )
   {
      p->~T();
   }

   void deallocate( pointer p, size_type nNum )
   {
      (void) nNum;
      delete[] p;
   }
};

这是错误：

Error   1   error C2512: 'std::_Aux_cont' : no appropriate default constructor available    c:\XXX\AllocPowOf2.h    97

在带有VS2008的Windows和带有Android NDK和eclipse的Android中，代码在调试模式下正确编译。

有什么想法吗？

Answer 1

return new value_type[ OptimizeNbBytes( nNum * sizeof( value_type ), 32 ) ];

暂时忽略OptimizeNbBytes，您new nNum * sizeof(value_type) value_type，这也多次调用value_type的构造函数。

换句话说，要求为16 int分配内存，你可以为64 int分配足够的内存;不仅如此，而且还要求您提供原始内存，而是在它们上面运行构造函数，创建将被容器覆盖而不会被销毁的对象 - 然后delete[]中的deallocate将导致双重破坏。

allocate应该分配原始内存：

return pointer(::operator new(OptimizeNbBytes( nNum * sizeof( value_type ), 32 )));

和deallocate应该在不运行任何析构函数的情况下释放内存：

::operator delete((void*)p);

STL的自定义分配器无法仅在发布模式下编译

1 个答案: