Question

我有一个类（在许多其他东西中）有一个指向unsigned char的指针，它被删除并重新分配以存储来自另一个数组的一些数据。这是通过函数

完成的

 class MyClass {
  private:
      unsigned char* m_Buffer;
      int m_BufferSize;
  public:
      bool SetBuffer(int iSize, const unsigned char* pArray); 
 };

 bool MyClass::SetBuffer(int iSize, const unsigned char* pArray) {
     bool bOK = false;
     if (pArray != NULL  && iSize > 0) {
         delete [] m_Buffer;
         m_Buffer = new unsigned char[iSize];
         memcpy(m_Buffer,pArray,iSize);
         m_BufferSize = iSize;
         bOK = true;
      }
      return bOK;
  }

我根本不喜欢这个代码，我真的想用std::vector<unsigned char>替换指针。我的问题是，我将如何执行memcpy方面？如果我将一个向量作为参数传递给我的函数，我可以使用迭代器复制它，但我无法控制参数参数类型，所以我坚持使用unsigned char*。有没有办法使用迭代器，或者将矢量调整到合适的大小，然后访问其内部数组，以便我仍然可以使用memcpy复制数据？甚至更好的东西使用迭代器？我知道我可以使用循环和push_back，但这对我来说似乎非常低效。我们将非常感激地收到任何建议。

Answer 1

实际上，迭代器是从指针建模的，因此数组中的指针被认为是实现RandomAccessIterator概念。

因此：

m_buffer.assign(pArray, pArray + Size);

Answer 2

我真的建议你这样避免原始指针。我认为管理std :: vectors而不是原始指针是个更好的主意。

class MyClass {
private:
    std::vector<unsigned char> m_Buffer;
    // No size member is needed, it is stored in m_Buffer
public:
    // No size parameter is needed, it is stored in Array
    void SetBuffer(const std::vector<unsigned char> &Array);
};

void MyClass::SetBuffer(const std::vector<unsigned char> &Array) {
    std::copy(Array.begin(), Array.end(), m_Buffer.begin());
}

假设您正在为MyClass管理原始数据，您将在复制构造函数和operator =上处理此指针（或者取而代之）：

MyClass::MyClass(const MyClass &Class) {
    m_BufferSize = Class.m_BufferSize;
    m_Buffer = new new unsigned char[m_BufferSize];
    memcpy(m_Buffer, Class.m_Buffer, m_BufferSize); 
}

MyClass::operator =(const MyClass &Class) {
    if (m_Buffer) delete [] m_Buffer;
    m_BufferSize = Class.m_BufferSize;
    m_Buffer = new new unsigned char[m_BufferSize];
    memcpy(m_Buffer, Class.m_Buffer, m_BufferSize); 
}

如果你不处理复制构造函数中的MyClass托管指针和operator =，那么最后会有两个MyClass实例管理同一个内存。

如何从原始数组到std :: vector执行等效的memcpy？

2 个答案: