C++ 是否可能有一个std:：vector<；char>；使用选定的内存对齐方式分配内存

我正在

向量

缓冲区中复制进程的内存，希望分配给该向量的内存具有比默认值更高的对齐度

这是因为我在缓冲区中寻找任意类型的模式，其中内存可以表示任何东西——我希望我寻找的任何值/类型对都能根据其类型对齐

也许我可以使用“偏移量”来解决这个问题，但我更希望我的字符缓冲区对齐

---

除了创建一个

向量

之外，还有其他方法吗？

我可以用一个自定义分配器来解决我的问题

带有

boost:：alignment:：aligned_分配器的示例

#include <vector>
#include <boost/align/aligned_allocator.hpp>

template <typename T>
using aligned_vector = std::vector<T, boost::alignment::aligned_allocator<T, 16>>;
// 16 bytes aligned allocation

#包括
#包括
模板
使用对齐的_vector=std:：vector；
//16字节对齐分配

另请参见。
为此，我使用了类似以下的方法：


#include <iostream>
#include <vector>

template<typename T>
class AlignedVector {
 public:
  AlignedVector() : data_(nullptr) {}
  AlignedVector(int n)
      : char_vec_(sizeof(T)*(n+1)),
        data_(AlignedAddr(char_vec_.data())),
        size_(n) {}

  T* operator[](size_t n) { return data_[n]; }
  const T* operator[](size_t n) const { return data_[n]; }

  T* data() { return data_; }
  const T* data() const { return data_; }

  size_t size() const { return size_; }
  void resize(size_t n) {
    char_vec_.resize(sizeof(T)*(n+1));
    data_ = AlignedAddr(char_vec_.data());
    size_ = n;
  }

 private:
  static T* AlignedAddr(char* addr) {
    return (T*)(addr + sizeof(T) - ((size_t)addr % sizeof(T)));
  }

  std::vector<char> char_vec_;
  T* data_;
  size_t size_;
};

int main()
{
  AlignedVector<int[128]> vec(13);
  std::cout << (size_t)vec.data() << std::endl;
}


#包括
#包括
模板
类对齐向量{
公众：
AlignedVector（）：数据_U4;（nullptr）{}
对齐向量（整数n）
：char_vec(sizeof（T）*（n+1）），
数据（alignedAddress（char_vec_uu.data（）），
大小_un（n）{}
T*运算符[]（大小_tn）{返回数据_[n]；}
常量T*运算符[]（size_T n）常量{return data_u[n]；}
T*data（）{返回数据}
常量T*data（）常量{返回数据}
size_t size（）常量{返回大小}
空心调整大小（大小\u t n）{
字符向量大小（sizeof（T）*（n+1））；
data_uu=AlignedAddr（char_uvec_uu.data（））；
尺寸=n；
}
私人：
静态T*AlignedAddr（char*addr）{
返回（T*）（地址+大小（T）-（大小（T）地址%大小（T））；
}
标准：：向量字符向量；
T*数据；
大小\u t大小\u；
};
int main（）
{
对齐向量向量向量（13）；
std：：你们能不能提供一个自定义的分配器来分配内存和你们的对齐要求。我们会很期待的。谢谢。@Yashas请不要在评论部分对答案提出技术建议，绕过同行评议系统。这就是答案部分的目的。若你们并没有时间写完整的答案现在就回答，没关系：其他人可以做到！干杯：）