MyClass& operator=(const MyClass& other) {
    if(this != &other) {
         * * *
    }
}

MyClass& operator=(const MyClass& other) {
    assert(this != &other)
    * * *
}

X a;
// много индусского кода...
const X& b = a;
// moarrrr!
a = b;

X& operator=(const X& rhs){
    clear_me();
    X tmp(rhs);
    swap(&this, tmp); //BOOM!
    return *this;
}

B>X& operator=(const X& rhs){
B>    clear_me(); // Эвона как. А если сконструировать не получится???
B>    X tmp(rhs); 
B>    swap(&this, tmp); //BOOM! Причем на этапе компиляции. А если поправить ошибку - то получим горку бессмысленного кода.
B>                      // swap должен быть перегружен для X и не кидать исключения. Иначе получим рекурсию. А если перегружен - то не получим ошибку, за исключением выше.
B>    return *this;
B>}

B>

X & operator = (X rhs)
{
    using namespace std;
    swap(*this, rhs);
    return *this;
}

B>Так что лучше уж проверить

AS>>X & operator = (X rhs)
AS>>{
AS>>    using namespace std; // а вот за такое... да два-три раза...
AS>>

AS>// swap должен быть перегружен для X и не кидать исключения. Иначе получим рекурсию. А если перегружен — то не получим ошибку, за исключением выше.

Просто посмотреть гвайд:

X & operator = (X rhs)
{
using namespace std;
swap(*this, rhs);
return *this;
}

AS>// swap должен быть перегружен для X и не кидать исключения. Иначе получим рекурсию. А если перегружен — то не получим ошибку, за исключением выше.

AS>>// swap должен быть перегружен для X и не кидать исключения. Иначе получим рекурсию. А если перегружен — то не получим ошибку, за исключением выше.

MyClass& operator=(const MyClass& other) {
A>    if(this != &other) {
A>         * * *
A>    }
A>}

MyClass& operator=(const MyClass& other) {
A>    assert(this != &other)
A>    * * *
A>}

using namespace std;

struct MyType
{
    int value;
    
    MyType& operator=(const MyType& r) {
        if(this == &r)
            cout << "this == &r" << endl;
        value = r.value;
        return *this;
    }
    
    friend bool operator<(const MyType& l, const MyType& r) {
        return l.value < r.value;
    }
};

int main()
{
    MyType a{1};
    MyType b{2};
    
    a = min(a, b);
    
    return 0;
}

X& operator=(const X& rhs){
    clear_me();
    X tmp(rhs);
    swap(&this, tmp); //BOOM!
    return *this;
}

template<class _Ty> inline
    void swap(_Ty& _Left, _Ty& _Right)
    {    // exchange values stored at _Left and _Right
    _Ty _Tmp = _Left;
    _Left = _Right;
    _Right = _Tmp;
    }

AS>X& operator=(const X& rhs){
AS>    clear_me();
AS>    X tmp(rhs);
AS>    swap(&this, tmp); //BOOM!
AS>    return *this;
AS>}
 
AS>

this->swap(tmp);

X & operator = (X rhs)
{
    using namespace std;

// swap должен быть перегружен для X и не кидать исключения. Иначе получим рекурсию. А если перегружен — то не получим ошибку, за исключением выше.

#include <iostream>

// Представьте, что доступа к этопу коду мы не имеем. Физически, организационно
// или просто люди, которые его разрабатывали или поддерживали, давно отсуствуют.
// На самом деле, это не сильно отличается от первого предположения
class LegacyObj
{
public:
    LegacyObj(int i):_i(new int(i)){}

    ~LegacyObj(){
        clear();
    }

    LegacyObj(const LegacyObj& rhs){
        clear();
        _i = new int(*rhs._i);
    }

    LegacyObj& operator=(const LegacyObj& rhs){
        
        // этот вызов явно лишний, но ничего с ним сделать не можем
        clear();

        // копируем наши "ресурсы"
        _i = new int(*rhs._i);
        
        // настоящие ковбои никогда не проверяют &rhs != this
        return *this;
    }

    void clear(){
        delete _i;
        // _i = 0; - если бы еще обнулили этот указатель, это нам бы помогло при отладке
    }

    void print_me(){
        std::cout << *_i << std::endl;
    }

private:
    // вместо int* могут быть любые ресурсы, требующие аллокации
    int* _i;
};

// Какая-то обертка вокруг старого кода

// Версия с проверкой
class WrapperWithCheck
{
public:
    
    WrapperWithCheck(int a, int b, int c):_a(a),_b(b),_c(c){}

    WrapperWithCheck(const WrapperWithCheck& rhs):_a(rhs._a),_b(rhs._b),_c(rhs._c){}

    WrapperWithCheck& operator=(const WrapperWithCheck& rhs){
        if(&rhs == this)
            return *this;

        _a = rhs._a;
        _b = rhs._b;
        _c = rhs._c;
        return *this;
    }

    void print_me(){
        _a.print_me();
        _b.print_me();
        _c.print_me();
    }

private:
    LegacyObj _a;
    LegacyObj _b;
    LegacyObj _c;
};


// Версия без проверки
class WrapperWithoutCheck
{
public:

    WrapperWithoutCheck(int a, int b, int c):_a(a),_b(b),_c(c){}

    WrapperWithoutCheck(const WrapperWithoutCheck& rhs):_a(rhs._a),_b(rhs._b),_c(rhs._c){}

    WrapperWithoutCheck& operator=(const WrapperWithoutCheck& rhs){
        _a = rhs._a;
        _b = rhs._b;
        _c = rhs._c;
        return *this;
    }

    void print_me(){
        _a.print_me();
        _b.print_me();
        _c.print_me();
    }

private:
    LegacyObj _a;
    LegacyObj _b;
    LegacyObj _c;
};

int main() {
    
    {
        WrapperWithCheck wrapper_with_check(1, 2, 3);
        WrapperWithCheck other_wrapper(5, 6, 7);
        std::cout << "Object with check" << std::endl;
        wrapper_with_check.print_me();
        WrapperWithCheck& wrapper_ref = wrapper_with_check;

        // присваивание другому объекту
        other_wrapper = wrapper_with_check;

        // присваивание себе
        wrapper_with_check = wrapper_ref;
        std::cout << "After assignment" << std::endl;
        wrapper_with_check.print_me();
    }

    {
        WrapperWithoutCheck wrapper_without_check(1, 2, 3);
        WrapperWithoutCheck other_wrapper(5, 6, 7);
        std::cout << "Object without check" << std::endl;
        wrapper_without_check.print_me();
        WrapperWithoutCheck& wrapper_ref = wrapper_without_check;

        // присваивание другому объекту
        other_wrapper = wrapper_without_check;

        // присваиваем себе
        wrapper_without_check = wrapper_ref; 
        std::cout << "After assignment" << std::endl;
        // вывод здесь не определен
        // если бы обнулили указатель в clear() - получили бы debug assert и release crash
        wrapper_without_check.print_me();
    }
    return 0;
}

Object with check
1
2
3
After assignment
1
2
3
Object without check
1
2
3
After assignment
-842150451
-842150451
-842150451

AS>>X& operator=(const X& rhs){
AS>>    clear_me();
AS>>    X tmp(rhs);
AS>>    swap(&this, tmp); //BOOM!
AS>>    return *this;
AS>>}
 
AS>>

this->>swap(tmp);
B>

B>Я думаю, если вышеприведенные примеры вас не убедили, ваша квалификация недостаточна, чтобы меня оценивать

    LegacyObj& operator=(const LegacyObj& rhs){
        
        // этот вызов явно лишний, но ничего с ним сделать не можем// этот вызов явно лишний, но ничего с ним сделать не можем
        clear();
        // копируем наши "ресурсы"// копируем наши "ресурсы"
        _i = new int(*rhs._i);
        
        // настоящие ковбои никогда не проверяют &rhs != this// настоящие ковбои никогда не проверяют &rhs != this
        return *this;
    }

Правильный ответ — в абсолютном большинстве случаев сравнение с this не нужно. Только в очень редких кейзах, где необходимость оптимизации доказана профилированием, можно написать что-то более умное, чем типовая реализация.

// swap должен быть перегружен для X и не кидать исключения. Иначе получим рекурсию. А если перегружен — то не получим ошибку, за исключением выше.