0

编写一个重载的 operator+ 函数，以便可以将二次类的两个实例相加，如下面的代码所示：

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;
}

急切地寻求大师的帮助！任何帮助将不胜感激！

4

3 回答 3

0

好吧，从提供的函数来看，quadratic 有（至少）三个成员变量 a、b 和 c：

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

此外，我们可以推断出 quadratic 有一个接受 3 个 double 的构造函数和一个 operator+：

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

您在剩余实施的哪一部分遇到问题？

于 2010-09-14T00:21:52.957 回答
0

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

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

由于这是家庭作业，我将采用不同的示例。考虑编写一个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;
   }
};

为了约定，我们返回一个对vector2dfrom的引用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;
}

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

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

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并lhs在函数中使用。第二个参数是通过引用传递的，我们保证不会改变它（因此是 const）。运算结果存储在c.

于 2010-09-14T08:16:57.333 回答
0

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

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针对单个组件的方法。这可能具有较少的内存和处理开销，并且不允许修改组件，尽管它通过引用返回。

于 2010-09-14T08:46:23.270 回答