Question

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

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;

为了帮助你，这里是两个数字函数的实现：

double quadratic:: evaluate (const double x) {
return ((a * x * x) + (b * x) + c);
}

void quadratic::getCoefficients (double &A, double &B,
double &C) {
A = a; B = b; C = c;
}

拼命寻求大师的帮助！非常感谢任何帮助！

Answer 1

嗯，从提供的函数可以看出，二次方具有（至少）三个成员变量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;
};

您遇到问题的其余部分还有哪些？

Answer 2

简单的方法是使用一些一厢情愿的想法：在编写加法操作之前，只要认为你有两个对象。

真的，当你定义操作时，你正在编写一个稍后将被应用的算法。在通话地点，当某些用户键入a+b时，a和b必须是您要添加的类型的有效实例。在定义操作时，函数或方法的参数表示稍后将存在的有效实例的参数。

由于这是作业，我将遵循一个不同的例子。考虑编写一个vector2d类，其中包含两个代表x和y坐标的双精度数。

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

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

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

对于惯例，我们会从vector2d返回对operator+=的引用。我们在我们调用操作的对象（这是一个成员函数，*this对象）和我们作为参数的第二个对象上操作。请注意，此时在程序中没有创建单个对象，我们只是定义操作，而不是操作数。右侧参数rhs通过常量引用处理（我们获取对我们保证不会更改的对象的引用）。实际操作很简单，单独添加每个坐标，并且因为约定返回对修改对象的引用，我们返回*this。

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

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)，也就是说，它将调用对象operator+=上的成员方法a，通过{{1作为参数。

为了提供正确的加法操作，我们可以编写一个自由函数。添加不适用于两个参数中的任何一个，而是创建第三个参数，因此它有意义的是它不是成员方法。

此实现是惯用的（常见模式）。实施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，因为它是免费功能。然后因为第一个参数是按值传递的，所以operator+( a, b )的副本在函数中被用作a。第二个参数通过引用传递，我们保证不会更改它（因此为const）。操作结果存储在lhs。

中

Answer 3

所以......你想声明这个函数吗？

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::getCoefficients和quadratic::evaluate确实应该对调用对象有持续的保护。此外，您可能只对单个组件使用inline const double& quadratic::getA() const等方法。这可能会减少内存和处理开销，并且不允许修改组件，尽管它通过引用返回。

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

3 个答案: