将任意元素存储在连续内存中

Question

我正在尝试创建一个数据结构，它将在连续内存中保存 N 种不同类型。所以在编译时我可以说我想存储 3 种不同类型的 4 个元素，在内存中它看起来像 111122223333。

我一直在使用可变参数模板方法，我认为它会做我想要的，但是我不确定如何在 add 方法中将元素添加到每个数组中。

template<std::size_t N, typename... Args>
class Batch
{
    private:
        std::tuple<std::array<Args, N>...> data_;
        size_t currentPos_;

    public:
        template<typename T>
        void addToArray(std::array<T, N>& array, const T& value)
        {
            array[currentPos_] = value;
        }

        void add(const Args&... values)
        {
            //????
            addToArray(/*array, value*/);

            currentPos_++;
        }

        const void* data()
        {
            &return data_;
        }
};


int main()
{
    Batched<3, float, double, int> b;

    b.add(1.0f, 1.0, 1);
    b.add(2.0f, 2.0, 2);
    b.add(3.0f, 3.0, 3);
    b.add(4.0f, 4.0, 4);
    return 0;
}

即使我让它工作，内存布局是否正确？有更好的方法吗？

Answer 1

我不认为这是一个好主意，但是……我只是为了好玩而展示它

使用std::vector<char>（以及C++11添加的方法data()授予的对以下内存的访问）和旧的memcpy()，我想你可以简单地按照以下方式进行

#include <vector>
#include <cstring>
#include <iostream>

template <typename... Args>
class Batch
 {
   private:
      std::vector<char> buffer;

   public:

      void addHelper ()
       { }

      template <typename T, typename ... Ts>
      void addHelper (T const & v0, Ts ... vs)
       { 
         auto  pos = buffer.size();

         buffer.resize(pos + sizeof(T));

         std::memcpy(buffer.data() + pos, & v0, sizeof(T));

         addHelper(vs...);
       }

      void add (const Args&... values)
       { addHelper(values...); }

      const void * data()
       { return buffer.data(); }

      void toCout ()
       { toCoutHelper<Args...>(0U, buffer.size()); }

      template <typename T, typename ... Ts>
      typename std::enable_if<(0U < sizeof...(Ts)), void>::type
         toCoutHelper (std::size_t  pos, std::size_t  size)
       {
         if ( pos < size )
          {
            T val;

            std::memcpy( & val, buffer.data() + pos, sizeof(T) );

            std::cout << " - " << val << std::endl;

            toCoutHelper<Ts...>(pos+sizeof(T), size);
          }
       }

      template <typename T, typename ... Ts>
      typename std::enable_if<0U == sizeof...(Ts), void>::type
         toCoutHelper (std::size_t  pos, std::size_t  size)
       {
         if ( pos < size )
          {
            T val;

            std::memcpy( & val, buffer.data() + pos, sizeof(T) );

            std::cout << " - " << val << std::endl;

            toCoutHelper<Args...>(pos+sizeof(T), size);
          }
       }

 };


int main()
 {
   Batch<float, double, int> b;

   b.add(1.0f, 1.0, 1);
   b.add(2.0f, 2.0, 2);
   b.add(3.0f, 3.0, 3);
   b.add(4.0f, 4.0, 4);

   b.toCout();

   return 0;
 }

--- EDIT ---：添加了一个方法，toCout() 打印（到std::cout）所有存储的值；只是建议如何使用这些值。

--- 编辑 2 ---：正如 ildjarn 所指出的（谢谢！），如果在 Args... 类型中是一些非 POD（普通旧数据）类型，则此解决方案非常危险。

this page 中解释的很好。

我转录相关部分

无法使用 memcpy 安全复制的类型的示例是 标准::字符串。这通常使用引用计数来实现 共享指针，在这种情况下，它将有一个复制构造函数 导致计数器递增。如果使用 memcpy 制作了副本 那么复制构造函数将不会被调用并且计数器将是 留下比应有的值低一的值。这很可能 导致包含 字符数据。

--- 编辑 3 ---

正如 ildjarn 所指出的（再次感谢！），使用此解决方案离开 data() 成员非常危险。

如果有人使用这样返回的指针

   char const * pv = (char const *)b.data();

   size_t  pos = { /* some value here */ };

   float  f { *(float*)(pv+pos) };  // <-- risk of unaligned access

在某些架构中，可能会导致访问未对齐地址中的 float *，从而导致程序终止

从data() 返回的指针中恢复值的正确（安全）方法是toCoutHelper() 中使用的方法，使用`std::memcpy()

   char const * pv = (char const *)b.data();

   size_t  pos = { /* some value here */ };

   float  f; 

   std::memcpy( & f, pv + pos, sizeof(f) );

Answer 2

有两种词汇类型可以帮助您。
std::variant 和 std::any。

std::variant 更适合您的预期用途。

不要像这样创建自己的类型：

Batched<3, float, double, int> b;

考虑使用：

std::vector<std::variant<float, double, int>> vec;

然后就可以正常添加元素了：

vec.emplace_back(1);    //int
vec.emplace_back(1.0f); //float
vec.emplace_back(1.0);  //double