标签: allocator

有以下代码段错误的明显原因吗？

#include <vector>
#include <emmintrin.h>

struct point {
    __m128i v;

  point() {
    v = _mm_setr_epi32(0, 0, 0, 0);
  }
};

int main(int argc, char *argv[])
{
  std::vector<point> a(3);
}

谢谢

编辑:我在linux/i686上使用g ++ 4.5.0,我可能不知道我在做什么,但是因为甚至以下的段错误

int main(int argc, char *argv[])
{
  point *p = new point();
}

我真的认为它必须和对齐问题.

我试图使用自定义分配器std::vector<char>,但我注意到std::vector不需要/使用我的分配器中的任何成员函数.这怎么可能？

#include <vector>

struct A : private std::allocator<char> {
   typedef std::allocator<char> alloc;
   using alloc::value_type;
   using alloc::pointer;
   using alloc::const_pointer;
   using alloc::difference_type;
   using alloc::size_type;
   using alloc::rebind;
   // member functions have been removed, since the program compiles without them
};

int main() {
    std::vector<char, A> v;
    v.resize(4000);
    for (auto& c : v)
      if (c)
         return 1; // never happens in my environment
   return 0; // all elements initialized to 0. How is this possible?
}

我正在使用在线C++ 11编译器(LiveWorkSpace)尝试上述程序,提供g ++ 4.7.2,4.8和4.6.3. …

在阅读有关C++和标准库的书籍时,我看到频繁引用分配器.

例如,Nicolai Josuttis的C++标准库在最后一章中详细讨论了它们,并且第2项("了解分配器的约定和限制")和11("理解自定义分配器的合法用途")在Scott Meyers的有效的STL是关于它们的使用.

我的问题是,分配器如何代表一个特殊的内存模型？默认的STL内存管理不够吗？何时应该使用分配器？

如果可能,请使用简单的内存模型示例进行说明.

成员函数的文档std::allocator<T>::allocate在 ( [allocator.members] ) 中说：

\n

备注:数组的存储是通过调用 \xe2\x80\x8b::\xe2\x80\x8boperator new ([new.delete]) 获得的，但未指定该函数的调用时间和频率。该函数启动数组对象的生命周期，但不启动任何数组元素的生命周期。

\n

我想知道为什么它说::operator new而不只是operator new？双冒号有什么区别吗？operator new如果省略了双冒号，这里可以调用哪个其他的？

我编写了一个简单的C++ 11样式的有状态分配器类型.特定

template<typename T> class my_allocator {
   // the usual stuff
};

template<typename T> using my_vector = std::vector<T, my_allocator<T>>;

my_vector<int> x;

std::vector<int> y = x; // error

什么是允许从转换的最佳方式my_vector为std::vector使用默认的分配？GCC 4.7(最近的svn)说

error: conversion from 'my_vector<int> {aka std::vector<int, my_allocator<int>>}' to non-scalar type 'std::vector<int>' requested

显然,这可以通过简单的转换函数来完成,例如

template<typename T> std::vector<T> to_std_vec(const my_vector<T>& v)  {
   return std::vector<T>(&v[0], &v[v.size()]);
   }

但这看起来非常不优雅.在C++ 11中有更好的解决方案吗？

当然,在这种情况下,移动语义是正确的,但我希望复制构造和分配工作而不会产生额外的噪音/打字.

我正在尝试使用简单的内存池分配器std::unordered_map.我使用这个相同的分配器似乎成功地使用了std::string和std::vector.我希望unordered_map(和vector)中包含的项目也使用这个分配器,所以我已经包装了我的分配器std::scoped_allocator_adaptor.

简化的定义集:

template <typename T>
using mm_alloc = std::scoped_allocator_adaptor<lake_alloc<T>>;

using mm_string = std::basic_string<char, std::char_traits<char>, mm_alloc<char>>;
using mm_vector = std::vector<mm_string, mm_alloc<mm_string>>;
using mm_map = std::unordered_map<mm_string, mm_vector, std::hash<mm_string>, std::equal_to<mm_string>, mm_alloc<std::pair<mm_string, mm_vector>>>;

初始化如下:

lake pool;
mm_map map { mm_alloc<std::pair<mm_string, mm_vector>>{pool} };

lake_alloc下面显示了迭代器代码的其余部分.我在Clang 3.3中得到的错误是它不能将它allocator_type(在这种情况下是字符串对的mm_alloc)转移到它自己的错误__pointer_allocator.这是用于哈希映射实现的内部类型.部分错误输出如下:

lib/c++/v1/__hash_table:848:53: error: no matching conversion for functional-style
      cast from 'const allocator_type' (aka 'const std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<std::__1::pair<std::__1::basic_string<char,
      std::__1::char_traits<char>, std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<char, krystal::lake> > >, std::__1::vector<std::__1::basic_string<char,
      std::__1::char_traits<char>, std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<char, krystal::lake> > >,
      std::__1::scoped_allocator_adaptor<krystal::krystal_alloc<std::__1::basic_string<char, std::__1::char_traits<char>, …

我有一个内存接口,分离出获取地址空间与附加后备存储.(在Linux下,接口管理的地址空间池是mmap'ed MAP_ANONYMOUS和MAP_NORESERVE,madvise'ed MADV_DONTNEED和mprotect'ed PROT_NONE.然后通过madvise MADV_WILLNEED和mprotect PROT_READ,PROT_WRITE和PROT_EXEC附加支持.)

这个界面允许我分配大量的地址空间,同时懒洋洋地获取实际的物理内存.我想用它来创建一个"懒惰的向量",它在适当的点上提出后备存储请求,但是当它增长时从不复制向量的当前内容.

鉴于标准库的分配器的语义是这样的方案可能吗？感激地接受指针,提示或其他指导.

我试图使用std::unique_ptr<T[]>自定义内存分配器.基本上,我有自定义分配器,它们是子类IAllocator,提供以下方法:

void* Alloc( size_t size )
template<typename T> T* AllocArray( size_t count )
void Free( void* mem )
template<typename T> void FreeArray( T* arr, size_t count )

由于底层内存可能来自预先分配的块,我需要特殊的...Array()方法来分配和释放数组,它们分配/释放内存并调用T()/ ~T()范围内的每个元素.现在,据我所知,自定义删除器std::unique_ptr使用签名:

void operator()(T* ptr) const

在这种情况下unique_ptr<T[]>,通常你会调用delete[]并完成它,但我必须调用FreeArray<T>,为此我需要该范围内的元素数量.只给出了原始指针,我认为没有办法获得范围的大小,因此我唯一能想到的就是:

std::unique_ptr<T[], MyArrDeleter> somePtr( allocator.AllocArray<T>( 20 ), MyArrDeleter( allocator, 20 ) );

基本上,必须手动将数组的大小传递给删除对象.有一个更好的方法吗？这对我来说似乎很容易出错......

在技​​术上有效的是使用不匹配的特化std::allocator(当然,除了它的专业化void)作为STL容器的模板参数(不是全部,但下面列举加上无序_(多)映射/集)？以下代码编译正常.

#include <list>
#include <forward_list>
#include <deque>
#include <set>
#include <map>

int main()
{
    struct A { bool operator < (A) const { return true; } };
    struct B {};
    struct C {};
    std::list< A, std::allocator< C > > l;
    std::forward_list< A, std::allocator< C > > fl;
    std::deque< A, std::allocator< C > > d;
    std::set< A, std::less< A >, std::allocator< C > > s;
    std::multiset< A, std::less< A >, std::allocator< C > > ms;
    std::map< A, …

我知道std::array在堆栈中完全分配，但这个问题是出于安全考虑，需要两件事：

1. 中的数据std::array将在销毁时归零或随机化
2. 输入的数据std::array将被锁定，这样它就不会在崩溃或交换内存时进入磁盘。

通常，std::vector解决方案是创建一个自定义分配器来执行这些操作。然而，对于std::array，我不知道如何做到这一点，因此这个问题。

我能做的最好的是：

template <typename T, std::size_t Size>
struct SecureArray : public std::array<T, Size>
{
    static_assert(std::is_pod<T>::value, "Only POD types allowed")
    static_assert(sizeof(T) == 1, "Only 1-byte types allowed")
    virtual ~SecureArray()
    {
        std::vector<uint8_t> d = RandomBytes(Size); // generates Size random bytes
        std::memcpy(this->data(), d.data(), Size);
    }
}

但是，这显然缺乏记忆锁定和复杂化的表现方式std::array是通过使用来获得std::array在首位。

有没有更好的解决办法？