CODEWITHSUNDEEP
c++oopvisual-c++
derek
derek

Reputation: 836

C++ overloading the = operator

When overloading the = operator, should one make the contents of one object equal to the contents of the other object OR do you make the pointer of the object point to the same object?

Reading back on the question it seems that the contents should be copied and not the pointers. But I just can't figure it out, So I would be grateful if someone would explain what I should do, I know how to do both, I'm just not sure which one to choose.

class IntObject
{
private:
    int *pi_One;

public:

    IntObject(void);

    IntObject::IntObject(int const &i_one);

    ~IntObject(void);

    IntObject & operator=(const IntObject&);

};

IntObject::IntObject()
{
    pi_One = new int(0); 
}

IntObject::IntObject(int const &i_one)
{
    pi_One = new int(i_one); 
}

IntObject::~IntObject(void)
{
    delete pi_One;
}

IntObject & IntObject::operator=(const IntObject& c) {
//This copies the pointer to the ints
    this->pi_One = c.pi_One;

    return *this;  
}

Upvotes: 0

Views: 143

Answers (5)

Paul Manta
Paul Manta

Reputation: 31597

You should definitely copy the contents, not the pointers. Think about what you will do when one of the objects which both hold the same pointer is destroyed; you can't delete the pointer because the other object would be affected as well, but you can't not delete it either because you'd cause memory leaks. You'd have to use reference counting and everything would get a whole lot more complicated.

Upvotes: 2

Roman Saveljev
Roman Saveljev

Reputation: 2594

If you keep your destructor as it is, then you should change assignment overload. It would be also wise that nobody is attempting assigning IntObject to itself:

IntObject & IntObject::operator=(const IntObject& c) {
    if (this != &c)
    {
        //This copies the pointer to the ints
        *this->pi_One = *c.pi_One;
    }
    return *this;  
}

Otherwise, there will be attempt to free freed memory in IntObject's destructor

Upvotes: 0

David Rodríguez - dribeas
David Rodríguez - dribeas

Reputation: 208436

It depends on what semantics you want to have in your type. If you want value semantics, then copy the contents (deep copy, as is the case in std::vector), if you want reference semantics (shallow copy, as in std::shared_ptr)

Upvotes: 3

Littlegator
Littlegator

Reputation: 395

The principle of least astonishment would say to copy the content. When using operator= on any other object, you wouldn't expect it to copy pointers.

Upvotes: 0

Cubic
Cubic

Reputation: 15693

The contents should be copied (in fact, changing the pointer of the object shouldn't actually be possible - I can't imagine how you would do that - and even if it is somehow, you're not supposed to do it). You also have to take care of the differences between deep and shallow copies, especially if your class contains pointers (or containers with pointers in them).

Now that I think about it, I'm not even sure which pointer you could possibly want to reassign. Unless you are already working with a pointer - those already have an '=' operator that shouldn't be overloaded though.

Upvotes: 0

Related Questions