如何为这种 C++ 结构实现复制运算符？

Question

所以有

struct ResultStructure
{
    ResultStructure(const ResultStructure& other)
    {
        // copy code in here ? using memcpy ? how???  
    }
    ResultStructure& operator=(const ResultStructure& other)
    {
        if (this != &other) {
            // copy code in here ?
        }
        return *this
    }
    int length;
    char* ptr;
};

如何实现“复制构造函数”和“赋值运算符”？ （对不起 - 我是 C++ nube）

更新：sbi 和其他人问 - 为什么我要手动处理原始内存？我的答案很简单——在我参与的一个学生项目中，现在我们使用了很多 C 库，例如 OpenCV OpenAL 和 FFmpeg，还有更多。目前使用 C++，我们尝试创建一个基于图形的直接显示，如跨平台库，这将有助于实时视频广播和处理。我们的图形元素目前使用 char* 和 int 对进行数据交换。要将数据转换为订阅的元素，我们现在使用原始 memcpy。我想更进一步，让我们能够将我们的图形元素作为 C++ 模板的基础。因此，一个图形元素将能够与其他图形元素共享当前的图形元素数据，并且它共享的数据将是一种结构，其中不包含一个 char* 一个 int，而是包含任意数量的数据字段和几乎任何内部元素。所以这就是为什么我需要了解如何创建一个实现“复制构造函数”和“赋值运算符”的基本 C++ 结构，以便我能够为我们使用新的数据转换算法，如

void CastData(T item){
    for(size_t i = 0 ; i < FuncVec.size(); i++){
        T dataCopy = item;
        FuncVec[i](dataCopy);
    }
}

而不是当前使用的

void CastData(char * data, int length){
    for(size_t i = 0 ; i < FuncVec.size(); i++){
        char* dataCopy = new char[length];
        memcpy(dataCopy, data, length);
        FuncVec[i](dataCopy, length);
                    delete[] dataCopy;
    }
}

Answer 1

您可能想解释为什么您要手动处理原始内存。我已经很久没有这样做了，这就是 std::string 和 std::vector 的设计目的：

struct ResultStructure
{
    // nothing else needed

    std::string data; // or std::vector<char>
};

但是，如果您真的需要以艰难的方式来做这件事（这是家庭作业吗？），那么请注意，一开始要做到这一点非常困难。例如，赋值运算符的简单实现可能是这样的：

// DON'T TRY THIS AT HOME!!
ResultStructure& ResultStructure::operator=(const ResultStructure& rhs)
{
  delete[] ptr;                               // free old ressource
  ptr = new char[rhs.length];                 // allocate new resourse
  std::copy(rhs.ptr, rhs.ptr+rhs.length, ptr; // copy data
  length = rhs.length;
}

如果有人不小心将一个对象分配给自己（如果您只有两个引用并且您不怀疑它们引用同一个对象，则可能会发生这种情况），那么这将致命地失败。
另外，如果new 抛出异常怎么办？ （如果内存耗尽，它可能会抛出std::bad_alloc。）那么我们已经删除了旧数据并且没有分配新数据。然而，指针仍然指向旧数据曾经所在的位置（实际上，我认为这是实现定义的，但我还没有看到在删除时更改 ptr 的实现）和类的析构函数（你 知道该类需要一个析构函数，对吗？）然后会尝试删除没有分配数据的地址处的一条数据。那是未定义的行为。您可以期望的最好的结果是它会立即崩溃。

最简单的方法是使用Copy-And-Swap idiom：

struct ResultStructure
{
    ResultStructure(const ResultStructure& other)
     : ptr(new char[rhs.length]), length(rhs.length)
    {
        std::copy(rhs.ptr, rhs.ptr+rhs.length, ptr);
    }

    ~ResultStructure() // your class needs this
    {
      delete[] ptr;
    }

    ResultStructure& operator=(ResultStructure rhs) // note: passed by copy
    {
        this->swap(rhs);
        return *this
    }

    void swap(const ResultStruct& rhs)
    {
      using std::swap;
      swap(length, rhs.length); 
      swap(ptr, rhs.ptr); 
    }

    std::size_t length;
    char* ptr;
};

请注意，我添加了一个析构函数，更改了赋值运算符以传递每个副本的参数（我们需要调用复制构造函数来分配内存），并添加了一个swap 成员函数。按照惯例，swap() 函数永远不会抛出并且速度很快，最好是 O(1)。

我知道GMan's discussion of the Copy-And-Swap idiom 已经足够详尽和令人筋疲力尽，而mine 对你来说可能太简洁了，一开始你可能不会理解很多，但试着坚持下去，尽可能多地理解可能的。

Answer 2

如果您使用std::string，而不是char*，您甚至不需要编写operator= 或复制构造函数。编译器生成的代码会很好地完成您的工作。

但作为一般解决方案（对于其他一些场景），请使用复制和交换习语：

• Copy-and-Swap Idiom
• What is the copy-and-swap idiom?

Exceptional C++ by Herb Sutter 详细描述了这些。我建议您阅读本书中的内容。暂时可以在线阅读这篇文章：

• Exception-Safe Generic Containers

Answer 3

简单的解决方案是使用std::string 而不是char* 成员。

然后编译器生成的复制构造函数和复制赋值运算符就可以工作了。

作为一项规则，尤其是作为新手，不要有原始指针成员。

干杯，

Answer 4

正如已经说过的，并且正如在这个问题中所建议的那样，您可能应该重用现有的容器。至少代码是正确的:)

出于教育目的，让我们检查一下这个结构：

class Result
{
public:

private:
  size_t length; // can't really be negative, right ?
  char* data;
};

在这里，我们需要显式的内存管理。这意味着，值得注意的是，遵循Rule Of Three（感谢 Fred）

让我们从实际构建我们的对象开始：

Result::Result(): length(0), data(0) {}

Result::Result(size_t l, char* d): length(0), data(0)
{
  if (!d) { return; }

  data = new char[l]; // this may throw, so we do it first

  length = l;
  memcpy(data, d, l);
}

现在我们可以实现传统的运算符了：

// Swap
void Result::swap(Result& other)
{
  using std::swap;

  swap(length, other.length);
  swap(data, other.data);
}

// Copy Constructor
Result::Result(Result const& other): length(0), data(0)
{
  if (!other.length) { return; }

  data = new char[other.length];
  length = other.length;
  mempcy(data, other.data, length);
}

// Assignemt Operator
Result& Result::operator=(Result other)
{
  this->swap(other);
  return *this;
}

// !IMPORTANT!
// Destructor
Result::~Result()
{
  delete[] data; // use the array form of delete
                 // no need to test for nullity, it's handled
}

Answer 5

这是std::vector<char> 的工作 - 或者这是家庭作业？

向量将替换length 和ptr 后面的分配。向量是 c++ 习惯用法，如果您像您描述的那样实现类，您将不会与其他 c++ 开发人员交朋友。当然，也有极端情况，但标准容器如vector是默认的。

vector 知道如何复制 chars 以及它自己，并且实现已经过优化和测试。

以下是使用向量显式实现复制 ctor/assign 的方法：

struct ResultStructure {
    ResultStructure(const ResultStructure& other) : d_chars(other.d_chars) {
    }

    ResultStructure& operator=(const ResultStructure& other) {
        if (this != &other) {
            this->d_chars = other.d_chars;
        }
        return *this;
    }
    std::vector<char> d_chars;
};

Answer 6

我认为这应该可以完成工作：

struct ResultStructure
{
    ResultStructure(const ResultStructure& other);
    ResultStructure& operator=(const ResultStructure& other);

    int length;
    char* ptr;
};

ResultStructure::ResultStructure(const ResultStructure& other):length(other.length)
{
    ptr = (char*)malloc(length);
    memcpy(ptr, other.ptr, length);
}

ResultStructure& ResultStructure::operator=(const ResultStructure& other)
{
    length = other.length;
    ptr = (char*)malloc(length);
    memcpy(ptr, other.ptr, length);
    return *this;
}

请记住在析构函数中释放 ptr。 ptr下存储了什么？如果是文本，为什么不使用 std::string？无论如何，您可以使用 std::vector。那么构造函数会容易得多......

Answer 7

ptr 指向的内存是如何分配的？

如果使用new，分配new，设置length然后复制

other.length = length;
other.ptr = new char[length];
memcpy( other.ptr, ptr, length );

如果您使用malloc 分配内存，请用对malloc 的调用代替对new 的调用。如果您正在使用其他一些内存方案，请弄清楚。 :)