标签: allocator

我知道我可以使用语法为矢量设置自定义分配器vector<T, Alloc>.有没有办法我可以为字符串做同样的事情？

我编写了一个简单的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中有更好的解决方案吗？

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

我试图分配的大小的存储器块size需要被Alignment对齐,其中尺寸可以在编译时定义.我知道例程,如_aligned_alloc,posix_memalign,_mm_alloc,等存在,但我不希望为他们带来降低代码的可移植性使用它们.
C++ 11给出了一个例行程序std::align,并且也是类std::aligned_storage从中我可以检索一个POD类型来分配将被对准以我的要求的元件.但是我的目标是创造条件,分配的内存块的分配size大小(不只是一个单一的元素),这将对齐.
这可能用std::align吗？我问的原因是std::align移动指针,使用该指针的类将给分配器一个指向移动的地址的指针,用于解除分配,这将是无效的.有没有办法以这种方式创建一个aligned_allocator？

我正在构建一个AVL树类,它将具有固定的最大项目数.所以我想的不是自己分配每个项目,而是一次分配整个块,并在需要时使用位图分配新的内存.

我的分配/解除分配代码:

avltree::avltree(UINT64 numitems)
{
  root = NULL;

  if (!numitems)
    buffer = NULL;
  else {
    UINT64 memsize = sizeof(avlnode) * numitems + bitlist::storagesize(numitems);
    buffer = (avlnode *) malloc(memsize);
    memmap.init(numitems, buffer + numitems);
    memmap.clear_all();
    freeaddr = 0;
  }
}

avlnode *avltree::newnode(keytype key)
{
  if (!buffer)
    return new avlnode(key);
  else 
  {
    UINT64 pos;
    if (freeaddr < memmap.size_bits)
      pos = freeaddr++;
    else
      pos = memmap.get_first_unset();
    memmap.set_bit(pos);
    return new (&buffer[pos]) avlnode(key);
  }
}

void avltree::deletenode(avlnode *node)
{
  if (!buffer)
    delete node;
  else
    memmap.clear_bit(node - …

在技​​术上有效的是使用不匹配的特化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, …

我想设计一个类模板,它采用分配器类型(在标准部分17.6.3.5中定义)作为模板参数.我看到如何使用默认设置来std::allocator_traits<A>填充任何缺少的成员A.除此之外,标准库或增强中是否有任何东西可以帮助正确使用分配器？

特别是:

1. 为了尊重typedef std::allocator_traits<A>::propagate_on_container_copy_assignment,我是否必须在具有类型成员的每个类的特殊成员函数中检查这些内容A？或者是否有一些我可以用作成员的包装类型来代替它来处理这些东西？

2. 如果我想通过在用户可见对象旁边存储额外数据来进行全面分配以减少分配数量,那么重新绑定分配器是否合适呢？

.

template<typename T, typename A>
class MyClass
{
private:
    //...
    struct storage {
        int m_special_data;
        T m_obj;
    };
    typedef typename std::allocator_traits<A>::template rebind_alloc<storage>
        storage_alloc;
    typedef typename std::allocator_traits<A>::template rebind_traits<storage>
        storage_traits;
    storage_alloc m_alloc;

    static T* alloc(T&& obj)
    {
        storage_traits::pointer sp = storage_traits::allocate(m_alloc, 1);
        sp->m_special_data = 69105;
        return ::new(&sp->m_obj) T(std::move(obj));
    }
    //...
};

我在阅读为什么C++分配器中没有重新分配功能？和是否有可能创建在运行时堆的数组,然后在需要时分配更多的空间？,这清楚地表明动态数组对象的重新分配是不可能的.

但是,在Josuttis 的C++标准库中,它声明了一个Allocator,它allocator具有一个allocate具有以下语法的函数

pointer allocator::allocate(size_type num, allocator<void>::pointer hint = 0)

其中hint有一个实现定义的含义,可用于帮助提高性能.

有没有利用这个的实现？

在大约十年前的一个项目中,我们发现std::vector动态分配导致了严重的性能损失.在这种情况下,它分配了许多小向量,因此快速解决方案是编写一个类似于向量的类,包装在基于堆栈的预分配char数组中,用作其容量的原始存储.结果是static_vector<typename T, std::size_t Max>.如果您了解一些基础知识,这样的事情很容易写,你可以在网上找到很多这样的野兽.事实上,现在也有一个提升.

现在在嵌入式平台上工作,我们碰巧需要一个static_basic_string.这将是一个字符串,它预先在堆栈上分配固定的最大内存量,并将其用作容量.

起初我认为这应该相当容易(static_vector毕竟它可以基于现有的),但再看看std::basic_string界面我不再那么肯定了.它比std::vector界面更复杂.特别是实现find()功能系列std::basic_string不仅仅是一项繁琐的工作.

这让我再次思考.毕竟,这就是创建分配器的原因:基于new和delete使用其他方法替换分配.但是,要说分配器接口不实用将是轻描淡写.有一些文章在那里解释它,但有一个原因,我在过去的15年中看到这么少的本土分配器.

所以这是我的问题:

如果你必须实现一个basic_string相似的,你会怎么做？

• 写你自己的static_basic_string？
• 写一个分配器来传递给std::basic_string？
• 做一些我没想到的事情？
• 使用来自提升的东西我不知道？

^{与往常一样,对我们来说存在相当重要的限制:在嵌入式平台上,我们与GCC 4.1.2绑定,因此我们只能使用C++ 03,TR1和boost 1.52.}

我正在尝试实现std::vector编程练习.

请考虑以下代码段:

template <class T, class Allocator = std::allocator<T>>
class vector
{
public:
    using size_type = size_t;
    using allocator_type = Allocator;
    ...
private:
    T* m_data;
    allocator_type m_alloc;
    size_type m_capacity;
    ...
}; 

m_data有类型T*.我需要分配使用std::allocator_traits<allocator_type>::allocate(m_alloc, m_capacity)哪个返回的内存std::allocator_traits<allocator_type>::pointer.

我可以假设,pointer可隐式转换T*并分配从返回的值allocate来m_data？

如果没有,如何正确分配内存vector？

相关但不重复：请参阅此答案的底部，在单击此问题下方的“关闭”按钮之前，我会解决您可能想要声明的重复项。

自动生成的ROS（机器人操作系统）消息 C++ 头文件包含如下类型定义：

typedef  ::std_msgs::Header_<std::allocator<void> > Header;

std::allocator<void>这里是什么意思？为什么是模板类型void？这是什么意思？什么时候使用？

这是文档std::allocator<>：

1. https://www.cplusplus.com/reference/memory/allocator/
2. https://en.cppreference.com/w/cpp/memory/allocator

这是要查看的自动生成文件示例：http : //docs.ros.org/en/electric/api/std_msgs/html/msg__gen_2cpp_2include_2std__msgs_2Header_8h_source.html。

上面的第一行是第 116 行。

这是自动生成的 ROS 消息Header_类的开始：

template <class ContainerAllocator>
struct Header_ {

这是自动生成的Header.h 的更多上下文，typedef底部有各种s：

template <class ContainerAllocator>
struct Header_ {
  typedef Header_<ContainerAllocator> Type;

  Header_()
  : seq(0)
  , stamp()
  , frame_id()
  {
  }

  Header_(const ContainerAllocator& _alloc)
  : seq(0)
  , stamp()
  , frame_id(_alloc)
  {
  }

  typedef uint32_t _seq_type;
  uint32_t seq;

  typedef ros::Time …