# 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:

```cpp
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:

```cpp
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:

```cpp
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\.