operator overloading problem

[mahinkhan22]

i know its a big thing to look at
whats wrong with my assignment or addition operator
and here is the promblem

In function 'int main()':|

 no match for 'operator=' in 'r = Polynomial<T>::operator+(Polynomial<T>&) [with T = int](((Polynomial<int>&)(& q)))'|

note: candidates are: Polynomial<T> Polynomial<T>::operator=(Polynomial<T>&) [with T = int]|

#include<iostream>
#include<fstream>
#include<sstream>
#include<math.h>
#include<string>
using namespace std;
template<class T>
class Polynomial; //forward declaration
template<class T>
istream& operator>>(istream& in,Polynomial<T>& obj);//forward declaration
template<class T>
ostream& operator <<(ostream& out,const Polynomial<T>& obj);
//---------------------------------------------------------------------------
//class of Term that has two variables of type T

//--------------------------------------------------------
//class of polynomial that will contain a variable of term
template<class T>
class Polynomial
{
    private:
        Term<T>* arrOfTerm;
    public:
        Polynomial<T>();//will intialize a polynomial form coeffi 1 and exp1
        Polynomial(const Polynomial& obj);//copy constructor
        Polynomial(T coeffient[],int order);//coeffi are in array and order given
        Polynomial(Term<T> a[],int size);//the poly will be init by an array of
        //term which contains coeffi and exp and size is the size of array of term
        Polynomial(string);//a poly will be given in string form
        ~Polynomial();

        // String, UnString
		string toString();
		void pasrePolynomial(string);

        //methods
        void setXthTerm(int x);//done
        void showXthTerm(int x);//done
        T evaluate();//done

        //input and display functions
        void getInput();//done
        static Polynomial input();//done
        void display();//done


        //operators  =, +, -, *, ==, !=, <<, >>, []
        Polynomial operator =( Polynomial<T>& obj);//done
        //static Polynomial<T> operator =(const Polynomial<T>& obj);
        Polynomial operator +( Polynomial& obj);
        //static Polynomial operator +(const Polynomial& obj1,const Polynomial& obj2);
        Polynomial operator -(const Polynomial& obj);
        Polynomial operator *(const Polynomial& obj);
        bool operator ==(const Polynomial& obj);//done
        bool operator !=(const Polynomial& obj);//done
        friend istream& operator >><T>(istream& in,Polynomial<T>& obj);//done
        friend ostream& operator <<<T>(ostream& out,const Polynomial<T>& obj);//done
        void operator [](int index);//done
};
template<class T>
Polynomial<T>::Polynomial()
{
    arrOfTerm = new Term<T>[3];
}
template<class T>
Polynomial<T>::Polynomial(const Polynomial& obj)
{
    int size;
    size = obj.arrOfTerm[0].getIndex();
    delete []arrOfTerm;
    arrOfTerm = new Term<T>[size];
    for(int i =0; i < size;i++)
    {
        arrOfTerm[i].setCoeffi( obj.arrOfTerm[i].getCoeffi());
        arrOfTerm[i].setExp(obj.arrOfTerm[i].getExp());
        arrOfTerm[i].setIndex(i+1);
    }
}
template<class T>
Polynomial<T>::Polynomial(T coefficient [], int order)
{
    delete []arrOfTerm;
    int pow = order;
    arrOfTerm = new Term<T>[order];
    for(int i = 0 ; i < order; i++,pow--)
    {
        arrOfTerm[i].setCoeffi( coefficient[i]);
        arrOfTerm[i].setExp(pow);
        arrOfTerm[i].setIndex(order);
    }
}
template<class T>
Polynomial<T>::~Polynomial()
{
    delete []arrOfTerm;
}

//input and display functions
template<class T>
Polynomial<T> Polynomial<T>::input()
{
    Polynomial obj;
    obj.getInput();
    return obj;
}
template<class T>
void Polynomial<T>::getInput()
{
    delete []arrOfTerm;
    T coefficient;
    T exponent;
    int noOfTerms;
    cout << "Enter how many terms you want to enter : ";
    cin >> noOfTerms;
    arrOfTerm = new Term<T>[noOfTerms];
    for(int i =0 ; i < noOfTerms;i++)
    {
        cout <<"Enter the coefficient of term  " <<i << "  : ";
        cin >>coefficient;
        cout <<"Enter  the  exponenet of term  " <<i << "  : ";
        cin >>exponent;
        arrOfTerm[i].setExp(exponent);
        arrOfTerm[i].setCoeffi(coefficient);
        arrOfTerm[i].setIndex(noOfTerms);
    }
}
template<class T>
void Polynomial<T>::display()
{
    for(int i =0 ; i < arrOfTerm[0].getIndex() ; i++)
    {
        cout << arrOfTerm[i].getCoeffi() << "x^"<<arrOfTerm[i].getExp();
        if(i < arrOfTerm[0].getIndex()-1)
        {
            cout << " + ";
        }
    }
}
//operators
template<class T>
ostream& operator<<(ostream& out,Polynomial<T>& obj)
{
    obj.display();
    return out;
}
template<class T>
istream& operator>>(istream& in , Polynomial<T>& obj)
{
    obj.getInput();
    return in;
}
template<class T>
Polynomial<T> Polynomial<T>::operator =( Polynomial<T>& obj)
{
    int size;
    size = obj.arrOfTerm[0].getIndex();
    delete []arrOfTerm;
    arrOfTerm = new Term<T>[size];
    for(int i =0; i < size;i++)
    {
        arrOfTerm[i].setCoeffi( obj.arrOfTerm[i].getCoeffi());
        arrOfTerm[i].setExp(obj.arrOfTerm[i].getExp());
        arrOfTerm[i].setIndex(size);
    }
}
template<class T>
bool Polynomial<T>::operator ==(const Polynomial& obj)
{
    if(arrOfTerm[0].getIndex()==obj.arrOfTerm[0].getIndex())
    {
        for(int i =0  ; i < arrOfTerm[0].getIndex();i++)
        {
            if(obj.arrOfTerm[i].getCoeffi()!=arrOfTerm[i].getCoeffi()
               || obj.arrOfTerm[i].getExp()!=arrOfTerm[i].getExp())
            {
                return 0;
            }
        }
    }
    return 1;
}
template<class T>
bool Polynomial<T>::operator !=(const Polynomial& obj)
{
    if(arrOfTerm[0].getIndex()==obj.arrOfTerm[0].getIndex())
    {
        for(int i =0  ; i < arrOfTerm[0].getIndex();i++)
        {
            if(obj.arrOfTerm[i].getCoeffi()!=arrOfTerm[i].getCoeffi()
               || obj.arrOfTerm[i].getExp()!=arrOfTerm[i].getExp())
            {
                return 1;
            }
        }
    }
    return 0;
}
template<class T>
void Polynomial<T>::operator[](int i)
{
    this->showXthTerm(i);
}
template<class T>
Polynomial<T> Polynomial<T>::operator+( Polynomial<T>& obj)
{
    Polynomial a;
    delete []a.arrOfTerm;
    int newSize;
    int noOfSimilarTerms;
    for(int i =0 ;  i< arrOfTerm[0].getIndex();i++)
    {
        for(int j =0; j<obj.arrOfTerm[0].getIndex();j++)
        {
            if(arrOfTerm[i].getExp() == obj.arrOfTerm[j].getExp())
            {
                noOfSimilarTerms++;
            }
        }
    }
    newSize = (obj.arrOfTerm[0].getIndex() + arrOfTerm[0].getIndex()) - noOfSimilarTerms;
    a.arrOfTerm = new Term<T>[newSize];
    for(int i =0 ;  i< arrOfTerm[0].getIndex();i++)
    {
        for(int j =0; j<obj.arrOfTerm[0].getIndex();j++)
        {
            if(arrOfTerm[i].getExp() == obj.arrOfTerm[j].getExp())
            {
               a.arrOfTerm[i].setCoeffi(arrOfTerm[i].getCoeffi()+obj.arrOfTerm[j].getCoeffi());
            }
        }
    }
}
int main ()
{

    //checking addition operator
    int a[3] ={2,2,2};
    Polynomial<int> p(a,3);
    Polynomial<int> q(a,3);
    Polynomial<int> r(a,3);
    //cin >>p;
    //cin >>q;
    r = p+q;
    cout << r;
    return 0;
}

[DarioDigiuni]

few remarks, if you don't mind

1. your operator+ is not returning anything
2. check the correct way to write operator= (which is not returning anything)
3. check const-correctness
4. all those delete's seem dangerous :)

[LB]

Templated classes must be defined inline.

[DarioDigiuni]

@L B

It's fine like this. Why do you say so?

[bluecoder]

Templated classes must be defined inline.

please elobrate .. not getting what you want to say .

[mahinkhan22]

Polynomial<T> Polynomial<T>::operator =( Polynomial<T>& obj)
{
    int size;
    size = obj.arrOfTerm[0].getIndex();
    delete []arrOfTerm;
    arrOfTerm = new Term<T>[size];
    for(int i =0; i < size;i++)
    {
        arrOfTerm[i].setCoeffi( obj.arrOfTerm[i].getCoeffi());
        arrOfTerm[i].setExp(obj.arrOfTerm[i].getExp());
        arrOfTerm[i].setIndex(size);
    }
    return *this;
}

Polynomial<T> Polynomial<T>::operator+( Polynomial<T>& obj)
{
    Polynomial a;
    delete []a.arrOfTerm;
    int newSize;
    int noOfSimilarTerms;
    for(int i =0 ;  i< arrOfTerm[0].getIndex();i++)
    {
        for(int j =0; j<obj.arrOfTerm[0].getIndex();j++)
        {
            if(arrOfTerm[i].getExp() == obj.arrOfTerm[j].getExp())
            {
                noOfSimilarTerms++;
            }
        }
    }
    newSize = (obj.arrOfTerm[0].getIndex() + arrOfTerm[0].getIndex()) - noOfSimilarTerms;
    a.arrOfTerm = new Term<T>[newSize];
    a.arrOfTerm[0].setIndex(newSize);
    for(int i =0 ;  i< a.arrOfTerm[0].getIndex();i++)
    {
        for(int j =0; j<obj.arrOfTerm[0].getIndex();j++)
        {
            if(arrOfTerm[i].getExp() == obj.arrOfTerm[j].getExp())
            {
               a.arrOfTerm[i].setCoeffi(arrOfTerm[i].getCoeffi()+obj.arrOfTerm[j].getCoeffi());
            }
        }
        a.arrOfTerm[i].setCoeffi()
    }
    return a;
}

here are the functions

i know that add is not adding properly but still the same error msg

ummm const correctness??

[LB]

Templated classes have to be defined inline because of the way templates work. Example:

template <typename T>
class SomeClass
{
    SomeClass()
    {
        //You define the member functions, constructors, etc. INSIDE the class
    }

    void DoSomething(int x)
    {
        //
    }
};

[mahinkhan22]

can we focus on the problem at hand ..... I am nearing submission deadline :(

[bluecoder]

Thanks L B :)

[ne555]

@LB: You mean in the same file.

Polynomial& operator=(const Polynomial &); Because you can't take a reference from a temporary (that is what operator+ returns). That will make it compile. I could not tested as you didn't provide the Term class.

You are exposing to danger with the use of pointers. You could avoid that with std::valarray or std::vector

[mahinkhan22]

its a runtime error this time
please help sent entire night on this and this one last thing isnot working

template<class T>
class Term
{
    private:
        T coeffi;
        T exp;
        int index; //for storing the max index
    public:
        //setters and getters
        void setCoeffi(T);
        void setExp(T);
        T getCoeffi();
        T getExp();
        void setIndex(int);
        int getIndex();
        //constructors and distructors
        Term();//term with coeffi and exp  1
        //Term(int);//term with coeffi
        //Term(int, int);
        //friend istream& operator>>(istream& in,Term<T>&obj);
};

template<class T>
Term<T>::Term()
{
    coeffi =1;
    exp =1;
    index =1;
}
template<class T>
void Term<T>::setIndex(int a)
{
    index =a;
}
template<class T>
int Term<T>::getIndex()
{
    return index;
}
template<class T>
void Term<T>::setCoeffi(T a)
{
    coeffi =a;
}
template<class T>
void Term<T>::setExp(T a)
{
    if(a > 0)
    {
        exp = a;
    }
    else
    {
        throw -1;
    }

}
template<class T>
T Term<T>::getCoeffi()
{
    return coeffi;
}
template<class T>
T Term<T>::getExp()
{
    return exp;
}

[mahinkhan22]

yes i have tried with the &

[Texan40]

As L B stated earlier you need to put the declaration and definition of the templated functions inline in the class not defined outside as you have it. (Unless I read his comments wrong)

[1yR4jE8b]

No you don't. They just have to be visible by the compiler at compile-time, not link-time. This means they can be defined in the separately in the same header file, inline, or in a separate file which is #include'd by the header file.

[LB]

Yes, darkestfright is right, inlining is just simpler :p

[mahinkhan22]

my problem ... my problem

[ne555]

Look at what are you doing

template<class T>
Polynomial<T>::Polynomial(T coefficient [], int order)
{
    delete []arrOfTerm; //¿when was arrOfTerm set to anything? 

Also, keep in mind the purpose of the forum. Don't worry, it will not derail

[mahinkhan22]

NOT HELPING

runtime error

[ne555]

Fine, we leave you alone then.

[mahinkhan22]

like you were ever helping...