C++ 编写一个重载运算符+函数，以便可以将二次类的两个实例添加到一起，如下代码所示：

编写一个重载运算符+函数，以便可以将二次类的两个实例添加到一起，如下代码所示：

quadratic y1 = quadratic (1.0, -5.0, 7.0);
quadratic y2 = quadratic (-3.0, -2.0, 10.0);
quadratic y3;
double result;

y3 = y1 + y2;
result = y1.evaluate (10.0);
cout << result <<endl;

---

拼命寻求上师的帮助！任何帮助都将不胜感激

从提供的函数中可以明显看出，二次型至少有三个成员变量，a、b和c：

class quadratic
{
public:
//...
private:
  double a, b, c;
};

此外，我们可以推断二次型有一个接受3倍的构造函数和一个运算符+：

class quadratic
{
public:
  quadratic(double A, double B, double C) {/*...*/}
  quadratic operator+(const quadratic &other) {/*...*/}
  //...
private:
  double a, b, c;
};

---

在剩下的实现中，您遇到了哪些问题？

简单的方法是使用了一些一厢情愿的想法：在编写加法操作之前，只需认为您确实拥有这两个对象

实际上，当您定义操作时，您正在编写稍后将应用的算法。在调用位置，当某些用户类型a+b时，a和b必须是要添加的类型的有效实例。定义操作时，函数或方法的参数表示稍后将存在的有效实例的参数

因为这是家庭作业，我将遵循一个不同的例子。考虑编写一个包含两个代表X和Y坐标的双倍的向量2D类。

class vector2d {
public:
   //...
private:
   double x,y;
};

您希望提供一些可以应用于vector2d对象的操作。您可以将运算符+=定义为将同一个向量与第二个向量相加的结果存储在向量中的一种方式：

class vector2d {
public:
   //...
   vector2d& operator+=( const vector2d& rhs )
   {
      x += rhs.x;
      y += rhs.y;
      return *this;
   }
};

对于约定，我们从运算符+=返回对矢量2D的引用。我们在调用操作的对象上操作，这是一个成员函数，*这个对象，以及作为参数的第二个对象。请注意，此时程序中没有创建单个对象，我们只是定义操作，而不是操作数。右手边的参数rhs是通过一个常量引用来处理的，我们得到了一个对我们承诺不改变的对象的引用。实际操作很简单，分别添加每个坐标，因为约定返回对修改对象的引用，所以我们返回*这个

我们已经定义了如何根据两个对象执行操作，现在我们可以使用它：

int main() {
   vector2d a( 5, 10 );    // assume that there is a constructor that 
                           // takes 2 doubles in the ellipsis above...
   vector2d b( 2.5, 7.5 );
   a += b;
}

现在，为了能够进行调用，用户需要有两个对象。为了定义操作，我们实际上不需要对象的实例，我们通过参数来抽象它。但要实际使用操作，我们确实需要操作的对象。此时，它们实际上被创建并命名为a和b。然后用户调用操作：a+=b。因为它是一个成员方法，所以编译器会将调用转换为一些不太漂亮的方法：a.operator+=b，也就是说，它将调用对象a上的成员方法operator+=b，并将b作为参数传递

为了提供适当的加法运算，我们可以编写一个自由函数。这个加法不适用于这两个参数中的任何一个，而是创建了第三个参数，所以它不是一个成员方法是有意义的

vector2d operator+( vector2d lhs, const vector2d & rhs )
{
   lhs += rhs;
   return lhs;
}

这种实现是一种惯用的通用模式。一旦我们实现了operatorX=我们就可以按照前面的方法实现operatorX。现在的诡计是：我们按值接受第一个参数。这样，编译器就为我们创建了一个副本。这个函数中的lhs不是加法的第一个参数，而是它的一个副本。然后，我们使用现有操作修改该本地副本，并将结果返回给用户。返回对象也是按值返回的

用法类似：

int main() {
   vector2d a( 5, 10 );
   vector2d b( 2.5, 7.5 );
   vector2d c = a + b;
}

---

在调用的地方，a+b被转换为运算符+a，b，因为它是一个自由函数。然后，因为第一个参数是按值传递的，所以会生成一个副本，并在函数中用作lhs。第二个参数是通过引用传递的，我们保证不会因此改变它。操作结果存储在c中。

因此。。。。是否要声明此函数

quadratic operator+(const quadratic& LHS, const quadratic& RHS);

作为一个整体来实施它

quadratic operator+(const quadratic& LHS, const quadratic& RHS)
{
    double LHSCoefficients[3];
    LHS.getCoefficients(LHSCoefficients[0], LHSCoefficients[1], LHSCoefficients[2]);
    double RHSCoefficients[3];
    RHS.getCoefficients(RHSCoefficients[0], RHSCoefficients[1], RHSCoefficients[2]);
    return quadratic(LHSCoefficients[0] + RHSCoefficients[0], LHSCoefficients[1] + RHSCoefficients[1], LHSCoefficients[2] + RHSCoefficients[2]);
}

---

非常简单，不需要是方法、静态方法或友元函数。请注意，quadratic:：getcoverties和quadratic:：evaluate确实应该对调用对象提供持续的保护。此外，对于单个组件，很可能只有内联常量double&quadratic:：getA const这样的方法。这可能会减少内存和处理开销，并且不允许修改组件，尽管它通过引用返回。

您需要帮助的部分是什么？编写运算符重载方法？或者如何做二次多项式的加法？我记得，二次系数形成了一个向量空间，所以你应该能够使用标准向量运算。操作符的实际功能是——在两个对象还没有创建的时候将它们相加。我会重载+=操作符来实现加法，然后根据重载的+=运算符重载+运算符。那么函数应该是二次op

---

运算符+双A，双B，双C？@HollerTrain No.首先，运算符+只能接受一个参数，如果将其作为成员函数，则至少是这样。其次，看看示例代码：y3=y1+y2+作用在二次对象y2上的有；根本没有双打。因此，您必须编写一个以二次对象作为参数的函数。哦，那么我的y1和y2是在运算符函数中加在一起的实际对象吗？但是在函数中，如果是在实际实现重载运算符之前，我怎么知道要加在一起的对象呢？这是整个问题的主要部分，我还不清楚

quadratic operator+(const quadratic& LHS, const quadratic& RHS)
{
    double LHSCoefficients[3];
    LHS.getCoefficients(LHSCoefficients[0], LHSCoefficients[1], LHSCoefficients[2]);
    double RHSCoefficients[3];
    RHS.getCoefficients(RHSCoefficients[0], RHSCoefficients[1], RHSCoefficients[2]);
    return quadratic(LHSCoefficients[0] + RHSCoefficients[0], LHSCoefficients[1] + RHSCoefficients[1], LHSCoefficients[2] + RHSCoefficients[2]);
}