Why doesn't the variable change as expected?

[stonedviper]

Ok so I'll admit i haven't been programming for a very while and I was trying to familiarize myself with how things work.

So here goes.

class sample
{
    public:
    string x;
    sample(string y)
    {
      x=y;  
    };
    sample operator+= (sample y)
    {
        return sample(this->x+y.x);
    }
    void print()
    {
        cout<<x<<"\n";
    }
};

int main()
{
    sample x("Hello "),y("There");
    x+=y;
    x.print();//why isn't the x variable modified?
}

I know that it can be done ike this

    sample const operator+= (const sample &y)
    {
        this->x=this->x+y.x;
        return *this;
    }

But I still want to know why doesn't my first variant work.

I'm pretty sure it has something to do with values and references but i couldn't find an answer specific to this example.

Thanks for answering :).

[Repeater]

x+=y;

This code could be seen as:

x.+=(y);

That is, calling the 'class function' += on the object x, with the parameter y.

Let's look at what that function does:

 sample operator+= (sample y)
    {
        return sample(this->x+y.x);
    }

It creates a completely new object of type sample, with the constructor sample(string y). A completely new one. Does it alter the existing class object (i.e. the x in x+=y;) at all? No.

Nothing to do with passing by value or reference. You're just not making any changes at all to the object.

[H00G0]

I think this is what you're trying to do:

#include <iostream>
#include <string>

using namespace std;

class sample
{
    public:
    string x;
    sample(string y)
    {
      x=y;  
    }
    void operator+= (sample y)
    { 
        x = (this->x + y.x);
    }
    void print()
    {
        cout<<x<<"\n";
    }
};

int main()
{
    sample x("Hello "),y("There");
    x+=y;
    x.print();//why isn't the x variable modified?
}

[Ganado]

operator+= generally should return a reference to the object changed.