Thread: Weird problem with overloading

I just recently started getting a syntax error with my = operator and my copy constructor, but I don't even call the copy constructor in my program. here's the relevant code:

[code]

Code:

//struct that contains the coefficient and exponent of each term 

struct term
{
  int co;                  //coefficient
  int exp;                //exponent
  term* link;
};

typedef term* termptr;

//class that contains the head of the list
class Polynomial
{
  public:
    Polynomial(Polynomial& p1);
    ~Polynomial();
    Polynomial() {head = NULL;}
    void operator = (Polynomial& p1);
    Polynomial operator + (Polynomial& p1);
    termptr get_head() {return head;}
    void set_head(termptr t1) {head = t1;}
    friend istream& operator >> (istream& ins, Polynomial& p1);
    friend ostream& operator << (ostream& outs, Polynomial& p1);
  private:
    termptr head;
};
//I'm not gonna list the definitions because I don't think they're relevant plus some of them are quite long

//here's my application file

int main()
{
  Polynomial p1, p2, result;

  cout << //prompt
  cin >> p1;    // the >> operator is overloaded for lists
  cout << //prompt
  cin >> p2;
  cout << endl;
  
  result = p1 + p2;
  cout << result;

  return 0;
}

okay, here's the error I keep getting:

error: no matching function for call to 'Polynomial::Polynomial(Polynomial)'
note: candidates are: Polynomial::Polynomial(Polynomial&)
error: initializing argument 1 of 'void Polynomial:perator =(Polynomial&)'

I get the error on this line in my application file: result = p1 + p2;

I have tried everything I can think of, but I know it's something simple. help me out please

list (const list& l1);

Remove the reference from

void operator = (list& l1);

without more info, can't suggest more.

I can't do

Code:

list::list(const list& l1)

because I call get_head() in the definition

I guess I can post my code for + and the copy constructor. the class isn't really called list, I just used that to simplify, it's actually called Polynomial and each node stores two ints instead of one. I edited the code in my first post to go with that. it's pretty long so I'll pseudocode parts of it

Code:

Polynomial::Polynomial (Polynomial& p1);
{
  termptr temp, temp1;
  temp = p1.get_head();
  
  if (temp == NULL)
    return;

  temp1 = new term;
  temp1->co = temp->co;
  temp1->exp = temp->exp;
  temp1->link = NULL;
  head = temp1;
  temp = temp->link;
  
  for (termptr ptr = temp; ptr != NULL; ptr = ptr->link)
  {
    temp1->link = new term;
    temp1 = temp1->link;
    temp1->co = ptr->co;
    temp1->exp = ptr->exp;
  }
}

// = operator overload is the same

Polynomial Polynomial::operator + (Polynomial& p1)
{
  Polynomial temp;
  termptr temp_ptr, current, result;
  termptr cursor_a = head, cursor_b = p1.get_head();

  if (cursor_a->exp > cursor_b->exp)
  {
    //creates new term
    //sets new term = cursor_a
    //call temp.set_head with the new term
    //increment cursor_a to the next node
  }else if (cursor_b->exp > cursor_a->exp)
  {
    //creates new term
    //sets new term = cursor_b
    //call temp.set_head with new term
    //increment cursor_a to next node
  }else
  {
    //slightly more complicated so I'll code this
    temp_ptr = new term;
    temp_ptr->co = cursor_a->co + cursor_b->co;
    temp_ptr->exp = cursor_a->exp;
    temp.set_head(temp_ptr);
    cursor_a = cursor_a->link;
    cursor_b = cursor_b->link;
  }

  current = temp.get_head();

  while ((cursor_a != NULL) || (cursor_b != NULL))
  {
    if (cursor_a == NULL)
    {
      current->link = new term;
      current = current->link;
      current->co = cursor_b->co;
      current->exp = cursor_b->exp;
      cursor_b = cursor_b->link;
    }else if (cursor_b == NULL)
    {
      //same thing except set values in current to cursor_a and increment cursor_a
    }else if (cursor_a->exp == cursor_b->exp)
    {
      //same thing except set current->co to cursor_a->co + cursor_b->co and increment
      //both
    }else if (cursor_a->exp > cursor_b->exp)
    {
      //same as if cursor_b == NULL
    }else if (cursor_b->exp > cursor_a->exp)
    {
      //same as if cursor_a == NULL
    }
  }
  return temp;
}

there it is, hope that helps

Oh but you are with your operator+ The return value of operator+ returns by value. To do so it uses the copy constructor.

That's what I assumed as well, but when I tried to construct an example to show that's what happens, I encountered something I didn't understand. Maybe you could tell me why the operator+ doesn't call the copy constructor below(or cause an error):

Code:

class Apple
{
public:
    int num;

    Apple(int a):num(a)
    {
        cout<<"constructor called"<<endl;
    }
    
    Apple(Apple& rA)
    {
        cout<<"copy constructor called"<<endl;
        num = rA.num;
    }
    
    Apple operator+(const Apple& rA)
    {
        //Apple A(num + rA.num);
        //return A;

        return Apple(num + rA.num);
    }
};


int main()
{
    Apple A(3);
    Apple B(1);

    Apple C = A + B;

    cout<<C.num<<endl;
    
    return 0;
}

Output:

constructor called
constructor called
constructor called
4
Press any key to continue

I don't get those errors in MS VC6. Is it mandatory that the parameter of a copy constructor be const? I realize it makes sense for it to be const, but is it required?

At this point you created an unnamed object. Well the compiler just made that unnamed object C. Since the return value is used in the initalization of C it just removed a few steps.

I don't understand that. Something is created within the function, and then it is passed to something outside the function. It seems to me, if it is passed by value, then the copy constructor should be called, and if it's not passed by value, then there should be an error because the return type is not a pointer or reference.