c++ - 动态数组类c++

Question

我正在编写一个动态数组类。我包含了一个复制构造函数和 operator= 函数，以允许我将一个数组分配给另一个数组。当我将相同长度的数组彼此分配时它起作用，但是当它们具有不同的长度时，我会收到编译器内存警告和/或代码炸弹而不执行，具体取决于左侧数组是否大于右侧数组，反之亦然。我有一个将值插入数组的函数，我认为问题可能出在这里(注意:我必须在析构函数中注释掉内存删除才能使代码运行)。

class Array
{
    private:
    int * ptr;
    int size; 
    int numElement;

public:
    Array();
    Array(const int*, int);
    Array(const Array&);
    ~Array();
    void setValueAtIndex(int, int);
    void insertValueAtEnd(int ); 
    int getArraySize();
    const Array& operator=(const Array& );  
};

#include "array.h"
#include <stdlib.h>
#include <iostream>
using namespace std;

Array::Array()
{
  size = 10;
  numElement = 0;
  ptr = new int[size];
  for (int i = 0; i < size; ++i)
  {
    ptr[i] = 0;
  }
}

Array::Array(const int * ptr_, int size_)
{
  size = size_;
  numElement = size;
  ptr = new int[numElement];
  for (int i = 0; i < size; ++i)
  {
    ptr[i] = ptr_[i];
  }
}

Array::Array(const Array& other)
{
  size = other.size;
  numElement = other.numElement;
  if (other.ptr)
  {    
      ptr = new int[numElement];
      for(int i = 0; i < size; ++i)
      {
        ptr[i] = other.ptr[i];
      }
      if(!ptr)
      {
        exit(EXIT_FAILURE);
      }
  }
  else ptr = 0;
}

Array::~Array()
{
  if(ptr)
  {
   //delete [] ptr;
   //ptr = 0;
  }
}

void Array::setValueAtIndex(int a, int b)
{
  if(b > size)
  {  
      exit(EXIT_FAILURE);
  }
  ptr[b] = a;
}

void Array::insertValueAtEnd(int insert)
{
  if(numElement == size)
  {
      size++;
  } 
  ptr[size-1] = insert;
  numElement++;
}

int Array::getArraySize()
{
  return size;
}

const Array& Array::operator=(const Array& other)
{    
    if(this != &other)
    {
     if (ptr)
     {
       delete [] ptr;
      ptr = 0;
     }
     numElement = other.numElement;
     size = other.size;
     if(other.ptr)
     {
       ptr = new int[numElement];
       for(int i = 0; i < size; ++i)
       {
         ptr[i] = other.ptr[i]; 
       }
     }
     else ptr = 0;
    }
    return *this;
}

Answer 1

您的代码存在多个问题!从复制构造函数中的一个次要的开始:if new T[n]失败，它不返回0 .相反，它会抛出异常。因此，您的测试 if (!ptr)永远达不到。在您的代码中，无论如何都为时已晚，因为您已经使用了指针!

赋值运算符完全是乱码!使用自赋值检查通常是一个很好的指示，表明代码不是异常安全的(如果没有此检查自赋值确实无法工作)或者您正在针对罕见情况进行优化(希望您不会将对象分配给自己比分配给其他对象更频繁)。在你的情况下，检查表明代码，如果它正在工作，将不是异常安全的:你开始删除内存，如果分配内存失败并抛出，你将无法取回。可能导致您悲伤的主要错误是您分配了 numElements对象(这似乎是数组中元素的数量，而不是它的容量)但是你复制了 size对象(这似乎是可能可用元素的数量，即 numElements < size )。作为旁注，我强烈建议您使用与标准 C++ 库为其容器使用的名称相同的名称，即 size()实际元素的数量和 capacity()为保留空间的元素数。

总而言之，实现赋值运算符的最佳方法是利用已经为复制构造函数和析构函数完成的工作:它们已经知道如何复制对象以及如何删除对象。执行此操作的方法如下所示:

Array& Array::operator= (Array other) {
    this->swap(other);
    return *this;
}
void Array::swap(Array& other) {
     std::swap(this->ptr, other.ptr);
     std::swap(this->size, other.size);
     std::swap(this->numElements, other.numElements);
}

这种方法要求还有一个函数swap()可以交换该类型的两个对象。然而，写起来通常很简单:你只是 std::swap()每个成员。