Adding Constructors using operators overloaded

[jhsyber]

SO i want to add the default constructor and the generic constructor or at least keep changing the values as i either add or subtract the values.

it prints the default, generic and then the negative values 3 times when it should print only once. can you please help.

#include <stdio.h>
#include <iostream>
#include <cmath>
using namespace std;

class Quadratic
{
private:
    double *cf, a , b, c;
public:
    Quadratic();
    Quadratic(int, int, int);
	Quadratic operator !(); 
	Quadratic operator +(Quadratic &); 
	Quadratic operator -(Quadratic &); 
	Quadratic operator +=(Quadratic &); 
	Quadratic operator ~(); 
	int geta(); 
	int getb();
	int getc();
    void print();
};
Quadratic::Quadratic()	//Default values
{
    a = 0;
    b = 0;
    c = 0;
	cf = new double[3];
    cf[0] = 0;
    cf[1] = 10;
    cf[2] = 20;
}
Quadratic::Quadratic(int a1, int b1, int c1)	//initializing array with new values
{
	a = a1;
    b = b1;
    c = c1;
    cf = new double[3];
    cf[0] = a;
    cf[1] = b;
    cf[2] = c;
}
Quadratic Quadratic::operator !() //changes values to negatives
{
	cf[0] *= -1;
	cf[1] *= -1;
	cf[2] *= -1;
	return *this;
}
Quadratic Quadratic::operator+(Quadratic &p)
//i want to add the currect values of the array with the new values
{
    cf[0] += p.geta();
    cf[1] += p.getb();
    cf[2] += p.getc();
	return *this;
}
Quadratic Quadratic::operator- (Quadratic &p)//substract the added values previously
{
    cf[0] -= p.geta();
    cf[1] -= p.getb();
    cf[2] -= p.getc();
	return *this;
}
Quadratic Quadratic::operator+= (Quadratic &p)//not sure how to use this operator
{
    cf[0] += p.geta();
    cf[1] += p.getb();
    cf[2] += p.getc();
	return *this;
}
Quadratic Quadratic::operator~ ()//calles the destructor
{
    delete [] cf;
    cout << "Destructor called.\n";
}
// since a b and c are private i use geta,b,c
int Quadratic::geta()
{
	return a;
}
int Quadratic::getb()
{
	return b;
}
int Quadratic::getc()
{
	return c;
}
void Quadratic::print()
{
    cout << "y = " << cf[0] << "x^2 " << cf[1] << "x " << cf[2]<< endl;;
}

//heres my main. I think the problem might be here
int main ()
{
    Quadratic Q1;
    Quadratic Q2(11, 22, 33);
    
	Q1.print();
	Q2.print();
	
	!Q2;
	Q2.print();

	Q2 + Q1;
	Q2.print();

	Q1 - Q2;
	Q2.print();

	Q2 += Q1;
	Q2.print();
	
	~Q2;
    
    return  0;
}

[xenovia12]

you didnt initialize a, b, c in your default constructor, so when Q1 was constructed a, b, c was given a garbage value

[jhsyber]

I tried both ways but it still won't add anything tho. I tried initializing a,b,c =0 or 10 still didn't work

[dhayden]

You need to change line 9 to:
double cf[3], a, b, c;
to avoid memory management problems. Come to think of it, why do you have a cf array AND values a, b, and c? You should have one or the other.

You have declared the destructor wrong. Line 17 declares a ~ operator. Line 17 should be :
~Quatratic();, but really, if you make the change above, then there's no need to define a destructor at all because there will be no need to free up memory.

Look at lines 107 and 108:

	Q2 + Q1;
	Q2.print();

If you needed to add integers, you wouldn't write:

int i1=1, i2=2;
i1+i2;
cout << i1;

because i1+i2 doesn't change i1, it just evaluates to a new integer. In particular, you don't want cout << i1+i2 to modify i1 as a side effect, and you really don't want cout << i1+i2+i3 to make changes to the variables along the way.

Your operators should work the same way. Q1+Q2 shouldn't change either Q1 or Q2. So your main program should be:

int main ()
{
    Quadratic Q1;
    Quadratic Q2(11, 22, 33);
    Quadratic Q3;
    
	Q1.print();
	Q2.print();
	
	Q3 = !Q2;
	Q3.print();

	Q3 = Q2 + Q1;
	Q3.print();

	Q3 = Q1 - Q2;
	Q3.print();

	Q2 += Q1;
	Q2.print();
    return  0;
}

Note that this applies to everything except the += operator. That one really DOES change the argument.

[ne555]

¿why do you have both `cf' and `a, b, c'?

> (+=) not sure how to use this operator
look at how that same operator is used on other types, by instance, int and std::string.
a += b; should be equivalent to a = a+b;, but the operator `+' should not modify its arguments.

> cf = new double[3];
unnecessary dynamic memory allocation, use an array.

> operator~ ()//calles the destructor
that isn't the destructor.