# V794. The assignment operator should be protected from the case of 'this == &src'.

The analyzer has detected a dangerous copy/move assignment operator that lacks a check for object self-assignment and at the same time contains operations that could cause memory leaks, use of deallocated pointers, and other problems, in case it receives a reference to '*this' as an argument.

Consider the following example:

    class C {
      char *p;
      size_t len;
    public:
      C& operator = (const C& other) {
        delete p;
        len = other.len;
        p = new char[len];
        std::copy(other.p, other.p + len, p);
        return *this;
      }
    };

The error will show if 'this == &other' and, therefore, 'p == other.p'. In that case, the uninitialized array will be copied into itself when the 'std::copy' call is executed.

Fixed code:

    C& operator = (const C& other) {
      if (this == std::addressof(other))
        return *this;
      delete p;
      len = other.len;
      p = new char[len];
      std::copy(other.p, other.p + len, p);
      return *this;
    }

If, however, you know that no such situation can occur, i.e. the operator has an implicit contract, it is recommended that you formalize this contract as an 'assert' construct:

    C& operator = (const C& other) {
      MyAssert(this != std::addressof(other));
      ....
    }

Note: It is better to use the 'std::addressof' function instead of the '&' operator to check a class for equality to itself. Then the check will work even if the class has overloaded '&' operator.

This diagnostic is classified as:

CWE-404

You can look at examples of errors detected by the V794 diagnostic.