Back to Home Page

/*******************************************************************************
Problem`: A one-variable quadratic expression is an arithmetic expression of the
form ax^2 + bx + c, where a,b, and c are some fixed numbers (called the
coefficients) and x is a variable that can take on different values.
Specify,design, and implement a CLASS that can store information about
a quadratic expression. The default constructor should set all three
coefficient to zero, and another constructor should allow you to
initialize these coefficients. There should be constant member functions
to retrieve the current values of the coefficients. There should also
be a member function to allow you to evaluate the quadratic expression
at a particular value of x (i.e., the function has one parameter x ,
and returns the value of the expression ax^2 + bx + c ).
Also overload the following operators ( as nonmember functions) to
perform these indicated operations:

Quadratic operator +( const Quadratic& q1, const Quadratic& q2 );

// Postcondition: The return value is the quadratic expression obtained
// by adding q1 and q2. For example, the c coefficient of the return
// value is the sum of q1's c coefficient and q2's c coefficient.

Quadratic operator *( double r , const Quadratic& q );

// Postcondition: The return value is the quadratic expression obtained
// by multiplying each of q's coefficient by the number r.

Notice that the left argument of the overloaded operator * is a double
number ( rather than a quadratic expression ). This allows expressions
such as 3.25 * q, where q is a quadratic expression.

In order to test your program you have to build your own main body for
your program.

Course: Objects Structures and Algorithms 2
Tutor: Guillermo Julca
Mercy College

View Output
*******************************************************************************/
//---------------------------------------------------------------------------
#include <iostream.h>
#include <conio.h>
#include "Quadratic.h"
#pragma hdrstop

//---------------------------------------------------------------------------

#pragma argsused
int main(int argc, char* argv[])
{
Quadratic q1(2,3,5);
Quadratic q2(6,8,10);
cout<<"Quadratic expression q1 is: ";
cout<<q1.getQuadraticCoefficient()<<"X^2 + "<<q1.getLinearCoefficient()<<"X + "<<q1.getFreeCoefficient()<<endl;
cout<<endl;
cout<<"Quadratic expression q2 is: ";
cout<<q2.getQuadraticCoefficient()<<"X^2 + "<<q2.getLinearCoefficient()<<"X + "<<q2.getFreeCoefficient()<<endl;
Quadratic qsum;
qsum = q1 + q2;
cout<<endl;
cout<<"Quadratic expression for q1 + q2 is: ";
cout<<qsum.getQuadraticCoefficient()<<"X^2 + "<<qsum.getLinearCoefficient()<<"X + "<<qsum.getFreeCoefficient()<<endl;
Quadratic qmult1, qmult2;
qmult1 = 3*q1;
qmult2 = 2*q2;
cout<<endl;
cout<<"Quadratic expression for 3 * q1 is: ";
cout<<qmult1.getQuadraticCoefficient()<<"X^2 + "<<qmult1.getLinearCoefficient()<<"X + "<<qmult1.getFreeCoefficient()<<endl;
cout<<endl;
cout<<"Quadratic expression for 2 * q2 is: ";
cout<<qmult2.getQuadraticCoefficient()<<"X^2 + "<<qmult2.getLinearCoefficient()<<"X + "<<qmult2.getFreeCoefficient()<<endl;
getchar();
return 0;
}
//---------------------------------------------------------------------------

// QUADRATIC.cpp File

#include <math.h>
#include "Quadratic.h"
Quadratic::Quadratic()
{
QuadraticCoefficient = 0;
LinearCoefficient = 0;
FreeCoefficient = 0;
}

Quadratic::Quadratic (double aQuadraticCoefficient, double aLinearCoefficient, double aFreeCoefficient)
{
QuadraticCoefficient = aQuadraticCoefficient;
LinearCoefficient = aLinearCoefficient;
FreeCoefficient = aFreeCoefficient;
}

double Quadratic::getQuadraticCoefficient() const
{
return QuadraticCoefficient;
}

double Quadratic:: getLinearCoefficient () const
{
return LinearCoefficient;
}

double Quadratic:: getFreeCoefficient () const
{
return FreeCoefficient;
}

double Quadratic:: evaluate( double x)
{
double result;
result = QuadraticCoefficient * pow(x,2) + LinearCoefficient * x + FreeCoefficient;
return result;
}

Quadratic operator +( const Quadratic& q1, const Quadratic& q2)
{
double qsumQuadraticCoefficient;
double qsumLinearCoefficient;
double qsumFreeCoefficient ;
qsumQuadraticCoefficient = q1.getQuadraticCoefficient() + q2.getQuadraticCoefficient();
qsumLinearCoefficient = q1.getLinearCoefficient() + q2.getLinearCoefficient() ;
qsumFreeCoefficient = q1.getFreeCoefficient() + q2.getFreeCoefficient() ;
Quadratic qsum( qsumQuadraticCoefficient , qsumLinearCoefficient , qsumFreeCoefficient );
return qsum;

}

Quadratic operator * (double r , const Quadratic& q)
{
double qmultQuadraticCoefficient;
double qmultLinearCoefficient;
double qmultFreeCoefficient ;
qmultQuadraticCoefficient = r * q.getQuadraticCoefficient();
qmultLinearCoefficient = r * q.getLinearCoefficient() ;
qmultFreeCoefficient = r * q.getFreeCoefficient();
Quadratic qmult( qmultQuadraticCoefficient , qmultLinearCoefficient , qmultFreeCoefficient );
return qmult;
}

//**************************************************************************************************************

// Quadratic.h HEADER FILE

#ifndef QUADRATIC_H
#define QUADRATIC_H

class Quadratic
{
public:
//CONSTRUCTORS
Quadratic();
Quadratic (double aQuadraticCoefficient, double aLinearCoefficient, double aFreeCoefficient);

//CONSTANT MEMBER FUNCTIONS
double getQuadraticCoefficient() const;
double getLinearCoefficient () const;
double getFreeCoefficient () const;

//MODIFICATION MEMBER FUNCTIONS
double evaluate( double x);

private:
double QuadraticCoefficient;
double LinearCoefficient;
double FreeCoefficient;
};

//NOMEMBER FUNCTIONS for the class Quadratic

Quadratic operator +( const Quadratic& q1, const Quadratic& q2);
Quadratic operator * (double r , const Quadratic& q);

#endif

//***********************************************************************************************

View Output

Back to Home Page

Copyright  © 2002                                   GJ  GUILLERMO JULCA