linked list -= operator overloading

so in main I have,

Code:

else if(user_input == 10){
    x -= y;
    }
    else if(user_input == 11){
    y -= x;
    }

and I am overloading the -= operator in my bag.cpp file like this,

Code:

void bag::operator -=(const bag& minuend)
    {
        node *cursor;
        cursor = minuend.head_ptr->link();
        while (cursor->link() != 0) {
            erase_one(cursor->data());
            cursor = cursor->link();
        }
    }

All of my other overloads are working but I have yet to figure this one out, maybe I need some sort of list searching algorithm for this? I have one of those that I could call from here but I am not sure how I could even use it in this situation. This is homework I have and it is due tonight... if something could give me a hint or something I would really appreciate it. Thanks!

Operators such as -= are supposed to return a reference to *this, i.e. a bag& in this case, rather than void.

Other than that, the code you have here is okay. You haven't asked a specific question, but if the problem is that this function does not do the right thing, then it looks to me like the problem would be in your erase_one function. I'll need to see that code to help further.

Code:

bool bag::erase_one(const value_type& target){
    node *target_ptr;
    
    target_ptr = list_search(head_ptr, target);
    if (target_ptr == NULL)
        return false; // target isn't in the bag
    target_ptr->set_data( head_ptr->data( ) );
    list_head_remove(head_ptr);
    --many_nodes;
    return true;
    }

The -= to my understanding is not working correctly... If I say x -= y then it should remove anything that is the same in x and y and put in x what remains. But, I posted you my erase one function.

My - and + work fine,

Code:

bag operator +(const bag& b1, const bag& b2){
    bag answer;

    answer += b1; 
    answer += b2;
    return answer;
    }
    
    bag operator -(const bag& b1, const bag& b2)
    {
        bag answer;
        
        answer = b1;
        answer -= b2;
        
        return answer;
    }

and also my += works correctly,

Code:

void bag::operator +=(const bag& addend)
    {
    node *copy_head_ptr;
    node *copy_tail_ptr;
    
    if (addend.many_nodes > 0)
    {
        list_copy(addend.head_ptr, copy_head_ptr, copy_tail_ptr);
        copy_tail_ptr->set_link( head_ptr ); 
        head_ptr = copy_head_ptr;
        many_nodes += addend.many_nodes;
    }
    }

Should I post more of my code?

Sorry for the delay, I'm only on here a couple of times a day at best. I hoped someone else would be able to help you in the mean time.

Using operator -= inside operator - is good and is the right way to go about it. However it really makes it hard to see how it could not work while operator - does.
I think what we need to see now, is some example for which it does not work.
Start with the simplest cases first:

Code:

{} -= {} --> should give {}
{} -= {1} --> should give {}
{1} -= {} --> should give {1}
{1} -= {1} --> should give {}

Then try larger examples:

Code:

{1, 2} -= {} --> should give {1, 2}
{1, 2} -= {1} --> should give {2}
{1, 2} -= {2} --> should give {1}
{1, 2} -= {1, 2} --> should give {}

Now, which of those cases does not work, and what happens when it goes wrong?