Question

我有一个函数foo(void* buffer, size_t len)，它根据buffer（大小为len）的数据计算哈希值，并将其附加到buffer的末尾。

通常我有一个传递给foo(&myVec[0], myVec.size())

的矢量

如何安全地将此功能与矢量一起使用？通过之前调整大小？

void foo(void* buffer, size_t len)
{
 if(buffer == NULL)
 { 
  printf("Error\n");
  return;
 }
 std::vector<unsigned char> hash(128);
 gethash(buffer, len, &hash[0]);
 unsigned char *data = ((unsigned char*) buffer) + len;
 memcpy(data, &hash[0], hash.size());

}

Answer 1

假设向量是vector<char>，你可以避免所有的混乱并且做：

 void foo(vector<char>& buffer)
 {
      std::vector<unsigned char> hash(128);
      gethash(buffer.data(), buffer.size(), hash.data());
      buffer.resize(buffer.size()+hash.size();
      unsigned char *data = buffer.data() + buffer.size();
      memcpy(data, hash.data(), hash.size());
 }

这仍然有点“混乱”，但比你发布的代码要少得多。

正如评论中所建议的那样：

     buffer.insert(buffer.end(), hash.begin(), hash.end());

可能比我写的最后三行更好。

Answer 2

你做不到！

如果buffer指向给定len的内存，则无法在此处重新分配更多内存。

处理它的两种方法：

缓冲区已经具有足够的数据和散列大小，但我更喜欢这个解决方案的结构！

或

为其分配新内存，复制数据和哈希值，并将指针返回到新数据内存。但是不要忘记以后释放这个内存以及输入内存。

第二种解决方案可以用载体

完成

void foo( vector<char> &vec )
{
...
    gethash(&vec[0], len, &hash[0]);
...

    vec.resize(...);  // reallocate and copy data if needed
    memcpy // which I do not want to use with a vector :-)

}

向量的大小调整会导致分配新内存并将数据从旧内存复制到新内存并释放分配的旧缓冲区。向量可能会按预期保存（更多）内存，因此不会发生重新分配。但是，在速度是一个标准之前，不能知道它的行为。但您也可以创建一个内部大小最小的向量，以防止自动分配和复制。

Answer 3

您可以在致电foo之前执行此操作：

int main() {
    std::vector<int> buffer;
    size_t sz = buffer.size();
    size_t tsz = sizeof(decltype(buffer)::value_type);
    buffer.resize(128 /  tsz + buffer.size());
    foo(buffer.data(), sz * tsz);
    return 0;
}

Answer 4

你可以这样做：

void foo(vector<unsigned char>& data)
{
    if(data.empty())
        return;

    vector<unsigned char> result(128);
    gethash(&data[0], data.size(), &result[0]);
    data.insert(data.end(), result.begin(), result.end());
}

安全使用在指针后写入数据的函数

4 个答案: