CERT C++: OOP54-CPP

Gracefully handle self-copy assignment

Description

Rule Definition

Gracefully handle self-copy assignment.¹

Polyspace Implementation

The rule checker checks for Self assignment not tested in operator.

Examples

Self assignment not tested in operator

Issue

Self assignment not tested in operator occurs when you do not test if the argument to the copy assignment operator of an object is the object itself.

Risk

Self-assignment causes unnecessary copying. Though it is unlikely that you assign an object to itself, because of aliasing, you or users of your class cannot always detect a self-assignment.

Self-assignment can cause subtle errors if a data member is a pointer and you allocate memory dynamically to the pointer. In your copy assignment operator, you typically perform these steps:

1. Deallocate the memory originally associated with the pointer.

   delete ptr;
   

2. Allocate new memory to the pointer. Initialize the new memory location with contents obtained from the operator argument.

    ptr = new ptrType(*(opArgument.ptr));
   

If the argument to the operator, opArgument, is the object itself, after your first step, the pointer data member in the operator argument, opArgument.ptr, is not associated with a memory location. *opArgument.ptr contains unpredictable values. Therefore, in the second step, you initialize the new memory location with unpredictable values.

Fix

Test for self-assignment in the copy assignment operator of your class. Only after the test, perform the assignments in the copy assignment operator.

Example - Missing Test for Self-Assignment

class MyClass1 { };
class MyClass2 {
public:
    MyClass2()                : p_(new MyClass1())      { }
    MyClass2(const MyClass2& f)   : p_(new MyClass1(*f.p_)) { }
    ~MyClass2()                {
        delete p_;
    }
    MyClass2& operator= (const MyClass2& f) //Noncompliant
    {
        delete p_;
        p_ = new MyClass1(*f.p_);
        return *this;
    }
private:
    MyClass1* p_;
};

In this example, the copy assignment operator in MyClass2 does not test for self-assignment. If the parameter f is the current object, after the statement delete p_, the memory allocated to pointer f.p_ is also deallocated. Therefore, the statement p_ = new MyClass1(*f.p_) initializes the memory location that p_ points to with unpredictable values.

Correction — Test for Self-Assignment

One possible correction is to test for self-assignment in the copy assignment operator.

class MyClass1 { };
class MyClass2 {
public:
    MyClass2()                : p_(new MyClass1())      { }
    MyClass2(const MyClass2& f)   : p_(new MyClass1(*f.p_)) { }
    ~MyClass2()                {
        delete p_;
    }
    MyClass2& operator= (const MyClass2& f)
    {
        if(&f != this) {
           delete p_;
           p_ = new MyClass1(*f.p_);
        }
        return *this;
    }
private:
    MyClass1* p_;
};

Check Information

Group: 09. Object Oriented Programming (OOP)

Version History

Introduced in R2019a