C++ 数组对复制构造函数和赋值运算符

Question

我在我的 C++ 程序中使用我的复制构造函数和赋值运算符。在单独测试它们中的任何一个时，我都会遇到分段错误（核心转储）。我正在构建一个哈希表，该哈希表是通过一个数组构造的，每个索引中有一对。索引是基于散列函数选择的，对的第一部分是键，对的第二部分是值。课程显然还有更多内容，但不会影响复制和赋值运算符，因此我将它们保留在那里。我没有内存泄漏，我测试了 op= 和复制构造函数，其中已经有很多值。

在 UnorderedMap.h 中

template <typename K, typename V>
class MyUnorderedMap: public Dictionary<K, V>
{
    private:
        MyPair<K, V> *m_data = nullptr; // hash table, array of pairs

        int data_size = 0; // current number of elements inside the array
        int reserved_size = 0; // max elements inside the array

    public:
        // Start data_size and reserved_size at 0, m_data to nullptr
        MyUnorderedMap();

        ~MyUnorderedMap();

        MyUnorderedMap(const MyUnorderedMap<K, V> &source);

        MyUnorderedMap<K, V> & operator=(const MyUnorderedMap<K, V> &source);
}

在 UnorderedMap.hpp 中

// Copy Constructor
template <typename K, typename V>
MyUnorderedMap<K, V>::MyUnorderedMap(const MyUnorderedMap<K, V> &source)
{
  data_size = source.data_size;
  reserved_size = source.reserved_size;
  m_data = new MyPair<K, V>[reserved_size];
  for(int i = 0; i < reserved_size; i++)
  {
    m_data[i].first = source.m_data[i].first;
    m_data[i].second = source.m_data[i].second;
  }
}


// Assignment Operator
template <typename K, typename V>
MyUnorderedMap<K, V> & MyUnorderedMap<K, V>::operator=(const MyUnorderedMap<K, V> &source)
{
  if(this!=&source)
  {
    delete[] m_data;
    reserved_size = source.reserved_size;
    data_size = source.data_size;
    m_data = new  MyPair<K, V>[reserved_size];
    for(int i=0; i<reserved_size; i++)
    {
      m_data[i].first = source.m_data[i].first;
      m_data[i].second = source.m_data[i].second;
    }
  }
  return *this;
}

在 MyPair.h 中

template <typename K, typename V> 
struct MyPair
{
    K first; 
    V second;

    MyPair(){}
    MyPair(const K &key): first(key) {}
    MyPair(const K &key, const V &value): first(key), second(value) {}
};

有没有人认为它为什么会这样表现有问题？ 我对我的复制构造函数比 operator= 更有信心。

Edit x3: 我有一个未显示的插入函数可以正确插入哈希表。所以我解决了复制构造函数，但 op= 仍然不起作用。我修复了上面的复制构造函数，所以现在它显示了一个工作复制构造函数，供任何想要将它用作有效工作基础的人使用。还修复了赋值运算符并提供了正确的版本。

Answer 1

m_data 被定义为UnorderedMap.h 中的一个指针，初始化为nullptr，但在实现中它被使用而不被分配给一些实际的存储。

Answer 2

我在你的复制构造函数中注意到你delete [] m_data，但是几行之后你开始给它赋值；这是一个大禁忌。在你delete [] 它之后，你必须使用m_data = new MyPair<K,V>[data_size]; 或类似的东西分配一个新数组。

我还注意到你只是在类声明中初始化你的类，使用

private:
    MyPair<K,V>* m_data = nullptr;
    data_size = 0;

等等。这通常不是 C++ 中初始化的工作方式。你必须把它放在实际的构造函数中，而且看起来你没有在代码中实现一个。

Answer 3

我假设Dictionary 具有正确的复制语义。

如果您采用 cmets 中的说明，您的代码应如下所示：

一、拷贝构造函数：

template <typename K, typename V>
MyUnorderedMap<K, V>::MyUnorderedMap(const MyUnorderedMap<K, V> &source) 
        : m_data(new MyPair<K, V>[source.reserved_size]),  // <-- You are missing this
          data_size(source.data_size), 
          reserved_size(source.reserved_size)
{
   for(int i = 0; i < reserved_size; i++)
   {
      m_data[i].first = source.m_data[i].first;
      m_data[i].second = source.m_data[i].second;
   }
}

复制构造函数使用member-initialization 列表。请注意，内存是在成员初始化列表中分配的。这是您的复制构造函数版本中没有的操作，也是您的代码的主要问题。

但是，还有其他问题，可以通过您的赋值运算符实现来解决。

你应该在复制构造函数之后实现的下一个函数是析构函数，不是赋值运算符。接下来要实现析构函数有一个战略原因，稍后会解释。

template <typename K, typename V>
MyUnorderedMap<K, V>::~MyUnorderedMap() 
{
   delete [] m_data;
}

既然你有了这两个函数，赋值运算符就变得微不足道了。但是，让我们回顾一下您的有缺陷的版本：

template <typename K, typename V>
MyUnorderedMap<K, V> & MyUnorderedMap<K, V>::operator=(const MyUnorderedMap<K, V>  
                                                       &source)
{
     if(this!=&source)
     {
         delete[] m_data;
         data_size = source.data_size;

让我们停在这里。最后两行代码可能损坏了您的对象。

原因是您更改了对象的成员，而您还没有分配内存。如果下一行对new[] 的调用抛出异常怎么办？您现在有一个处于无效状态的对象。

如果你这样写赋值运算符，应该这样写，确保所有内存都先分配好，然后开始调整对象的成员变量。

但是有一种更简单的方法可以避免这一切：

#include <algorithm>
//...
template <typename K, typename V>
MyUnorderedMap<K, V> & MyUnorderedMap<K, V>::operator=(const MyUnorderedMap<K, V>  
                                                       &source)
{
     if(this!=&source)
     {
         // create a temporary 
         MyUnorderedMap<K,V> temp(source);

         // swap out the temp's contents with the current object
         std::swap(temp.data, data);
         std::swap(temp.data_size, data_size);
         std::swap(temp.reserved_size, reserved_size);

         // temp will be destroyed when the if() goes out of scope
      }
      return *this;
  }

那么为什么会这样呢？很简单，代码基本上记录了做了什么。

您正在创建传入对象的副本。然后你用副本的内容交换当前对象的内容。然后副本（在if 块之后）与旧内容一起死亡。不存在抛出异常和创建无效对象的问题，复制构造函数和赋值运算符之间不存在冗余代码等问题。

这种编写赋值运算符的技术称为copy / swap idiom。它工作的唯一方法是如果你有一个 correct 复制构造函数和一个 correct 析构函数。这就是我们首先编写这两个函数的原因，以便利用 swap-ping 赋值运算符中的成员。