1

我有一个函数需要一个指向向量类型的指针uint16_t。这个函数用数据填充向量。我也有应该保存数据的对象，但是以类型向量的形式uint8_t。我的代码如下所示：

void fill1(vector<uint16_t> *data);
void fill2(vector<uint64_t> *data);

class Object
{
    uint32_t data_depth;
    vector<uint8_t> data;
}

Object object1;
object1.data_depth = 16;
fill1((vector<uint16_t>*) &object1.data);

Object object2;
object2.data_depth = 64;
fill2(vector<uint64_t>*) &object2.data);

// somewhere later in the code
if (object1.data_depth == 16)
   vector<uin16_t> * v = (vector<uint16_t>)(&objec1.data);

是不是不同类型向量指针转换的保存方式？

4

2 回答 2

3

你可能会做这样的事情：

template <typename T>
void fill(vector<unsigned char>& data)
{
    assert(data.size() % sizeof(T) == 0);

    T* pReinterpreted = reinterpret_cast<T*>(&data[0]);
    size_t count = data.size() / sizeof(T);

    // do some stuff with your array of reinterpreted values
}

class Object
{
    uint32_t data_depth;
    vector<unsigned char> data;
}

Object object;
fill<uint16_t>(object.data);

自然，这是不安全的代码，所以我不会这样做，除非你确切地知道这里的权衡是什么。

于 2013-07-21T19:56:57.960 回答
1

这是不安全的。从根本上讲，向量不是该类型的数组，而是包含一些数据的对象，包括指向该类型数组的指针。你做的那个演员会导致对额外数据的误解。事实上，你甚至不能保证 的实现vector不依赖于类型（我怀疑这在任何地方都可以完成——除了vector<bool>必须以不同的方式实现——但它绝对是允许的，只要所有单独的实现符合标准）。

您可以使用boost::variant允许将不同基本类型的向量存储在Object::data.

您的代码可能如下所示：

#include <boost/variant.hpp>

class Object
{
  boost::variant<std::vector<uint16_t>, std::vector<uint64_t> > data;
};

struct fill_visitor: boost::static_visitor<>
{
  template<typename T>
   void operator()(std::vector<T>& v)
  {
    fill(&v);
  }
};

// ...

boost::apply_visitor(fill_visitor(), object1.data);
于 2013-07-21T20:07:16.700 回答