为什么赋值运算符不能按预期工作？

Question

UPD: I can see now how stupid this question is, it's just my misunderstanding of C++ constructions.

I got stuck with operator assignment problem - it doesn't work as expected. Here's the example code:

#include <iostream>

class TestClass{
private:
    int pop;
public:
    TestClass(){
        std::cout<<"Default Constuctor\n";
    }
    TestClass(int i):pop(i){
        std::cout<<"Param Constuctor\n";
    }

    TestClass &operator=(const TestClass &other){
        std::cout<<"Assignment Operator \n";
        return *this;
    }

    friend std::ostream &operator<<(std::ostream &out, TestClass &x);
};

std::ostream &operator<<(std::ostream &out, TestClass &x){
    out<<" This is the TestClass with pop=" << x.pop <<"\n";
    return out;
}


int main()
{
    TestClass    P0(333);
    TestClass P_foo(555);

    P_foo = P0;

    std::cout << P0;
    std::cout << P_foo;

    return 0;
}

The result of this program is

Param Constuctor
Param Constuctor
Assignment Operator 
 This is the TestClass with pop=333
 This is the TestClass with pop=555

So P_foo object preserves the initialized value 555. If I comment out my custom assignment operator, the program works as expected.

Param Constuctor
Param Constuctor
 This is the TestClass with pop=333
 This is the TestClass with pop=333

What's wrong with my assignment operator function?

Answer 1

What's wrong with my assignment operator function?

At no point does *this get modified in your implementation of operator= :

    TestClass &operator=(const TestClass &other){
        std::cout<<"Assignment Operator \n";
        return *this;
    }

Answer 2

I see several issues with this code:

• pop is not being initialized in the default constructor (which you are not calling, but you should still implement it properly, if you are going to implement it manually at all).

• operator= is not updating the value of this->pop at all, which is the root cause of your issue. If you declare operator= , you are responsible for implementing it properly yourself, the compiler will not help you at all. But if you do not declare operator= , the compiler will auto-generate a default implementation that will assign a copy of the pop value for you.

• operator<< should be taking the TestClass parameter by const reference.

Try this:

#include <iostream>

class TestClass{
private:
    int pop;
public:
    TestClass() : pop(0) { // <-- add this value!
        std::cout << "Default Constructor\n";
    }

    TestClass(int i) : pop(i) {
        std::cout << "Param Constructor\n";
    }

    TestClass& operator=(const TestClass &other){
        std::cout << "Assignment Operator\n";
        pop = other.pop; // <-- add this!
        return *this;
    }

    friend std::ostream& operator<<(std::ostream &out, const TestClass &x);
};

std::ostream& operator<<(std::ostream &out, const TestClass &x){
    out << " This is the TestClass with pop=" << x.pop << "\n";
    return out;
}

int main()
{
    TestClass    P0(333);
    TestClass P_foo(555);

    P_foo = P0; // <-- this will work as expected now

    std::cout << P0;
    std::cout << P_foo;

    return 0;
}

Answer 3

TestClass &operator=(const TestClass &other){
    std::cout << "Assignment Operator \n";
    pop = other.pop;    // You need to add this
    return *this;
}

Answer 4

The issue is that the assignment operator you defined doesn't assign anything to the instance it is called on.

Read through your operator again:

TestClass &operator=(const TestClass &other){
    std::cout<<"Assignment Operator \n";
    return *this;
}

You can see that two things happen. Assignment Operator is printed, and *this is returned. But your "other" TestClass is not used at all, and the data in this is never modified.

You can fix that by assigning to this->pop like so:

TestClass &operator=(const TestClass &other){
    std::cout<<"Assignment Operator \n";
    pop = other.pop; // Now this->pop will be assigned a new value from other.pop
    return *this;
}

Now when you assign P_foo = P0 , P_foo is successfully assigned the pop value from P0 .