我有一个程序使用一个类来动态分配一个数组。我有重载运算符，可以对来自该类的对象执行操作。

当我测试这个程序时，重载的 += 工作，但 -= 不工作。 当试图运行重载的 -= 时程序崩溃，我得到以下运行时错误: p>

malloc: * error for object 0x7fd388500000: pointer being freed was not >allocated * set a breakpoint in malloc_error_break to debug

在私有(private)成员变量中，我这样声明数组:

double* array_d;

然后我在重载的构造函数中动态分配数组:

Students::Students(int classLists)
{
    classL = classLists;
    array_d = new double[classL];
}

我将以下两个重载构造函数定义为 Students 类的友元:

friend Student operator+= (const Student&, const Student&);
friend Student operator-= (const Student&, const Student&);

这些是这样定义的:

Student operator+= (const Student& stu1, const Student& stu2)
{
    if (stu1.getClassL() >= stu2.getClassL())
    {
        for (int count = 0; count < stu.getClassL(); count++)
            stu1.array_d[count] += stu2.array_d[count];

        return (stu1);
    }
    else if (stu1.getClassL() < stu2.getClassL())
    {
        for (int count = 0; count < stu1.getClassL(); count++)
                stu1.array_d[count] += stu2.array_d[count];

        return (stu1);
    }
}

Student operator-= (const Student& stu1, const Student& stu2)
{
    if (stu1.getClassL() >= stu2.getClassL())
    {
        for (int count = 0; count < stu2.getClassL(); count++)
            stu1.array_d[count] -= stu2.array_d[count];

        return (stu1);
    }
    else if (stu1.getClassL() < stu2.getClassL())
    {
        for (int count = 0; count < stu1.getClassL(); count++)
                stu1.array_d[count] -= stu2.array_d[count];

        return (stu1);
    }
}

基本上这里发生的事情是我比较两个对象，数组的大小基于 classL 而不同。 getClassL() 函数很简单:int Student::getClassL() const {return classLists;}

如果您想知道，我已经以这种方式让三巨头重载了:

<强>1。析构函数: Student::~Student() {delete [] array_d;}

<强>2。复制构造函数:

Student::Student(const Student &student)
{
    classLists = student.classLists;
    array_d = student.array_d;
}

<强>3。赋值运算符:

Student &Student::operator=(const Student &student)
{
    classLists = student.classLists;
    array_d = student.array_d;
}

奇怪的是 += 有效但 -= 无效，因为它们实际上是相同的。我怀疑我的问题出在我的动态内存分配上，但我不确定并正在寻求专家建议。

最佳答案

给你的建议是使用 std::vector 并且让你自己不必实现赋值运算符、复制构造函数和析构函数。

但话说回来，代码中有一些错误，更不用说复制构造函数了。

首先，复制构造函数应该分配一个全新的数组，并将传入值中的值从数组复制到新数组。这是您的 Student 类的简化版本，只有两个成员——一个 double * 和一个表示数组中项目数的整数。

class Student
{
   int num;
   double *array_d;

   public:
      Student(const Student &student);
      Student& operator=(const Student &student);
      ~Student() { delete [] array_d; }
      Student() : array_d(0), num(0) {}
};

复制构造函数看起来像这样:

Student::Student(const Student &student) : 
    array_d(new double[student.num]), num(student.num)
{
  for (int i = 0; i < num; ++i )
    array_d[i] = student.array_d[i];
}

一旦有了这个，赋值运算符就很简单了，使用 copy / swap:

Student& Student::operator=(const Student &student)
{
    Student temp = student;
    std::swap(d_array, temp.d_array);
    std::swap(num, temp.num);
    return *this;
}

基本上，上面所做的就是制作传入对象的临时拷贝，将临时对象的内部结构与当前对象交换，然后临时对象与旧内部结构一起消失。除非 Student 的复制构造函数和析构函数正常工作(它们现在应该正常工作)，否则所有这一切都是不可能的。

接下来要考虑的是您对运算符 += 和 -= 的整体想法。大多数程序员期望使用它的方式是在这种情况下:

Student a;
Student b;
// assume a and b are initialized and have data...
a += b;

如果您以不同的形式使用 += 或 -=，它会变得不直观而且很奇怪。因此，这些函数应该采用单个参数，而不是两个参数，并返回当前对象(它是您正在更改的当前对象)。

因此这些函数不应该是友元函数，而是Student的类成员函数:

class Student
{
   int num;
   double *array_d;

   public:
      Student(const Student &student);
      Student& operator=(const Student &student);
      ~Student() { delete [] array_d; }
      Student() : array_d(0), num(0) {}
      Student& operator += (const Student& rhs);
      Student& operator -= (const Student& rhs);
 };

那么 += 的实现看起来像这样:

#include <algorithm>
//...
Student& operator+= (const Student& stu1)
{
    int num_to_add = std::min(num, stu1.num);
    for (int count = 0; count < num_to_add; ++count)
        array_d[count] += stu1.array_d[count];
    return *this;
}

类似地，-= 看起来像上面那样。请注意使用 std::min 来确定要添加的数量，而不是使用 if/else 的原始代码。

关于C++:使用重载的复合赋值运算符时出现运行时错误，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/32706584/