Item 11：在 operator= 中处理 self-assignment

从“不同名字可能是同一个对象”开始

最明显是 w = w，但真实代码更常由 alias 形成：

Widget* px = &widget;
Widget* py = &widget;
*px = *py;

operator= 只看到 this 与 rhs，不能假定调用点名称不同就没有 alias。

经典错误：先 delete 再 copy

class Bitmap {
public:
    Bitmap& operator=(const Bitmap& rhs)
    {
        delete image_;
        image_ = new Image(*rhs.image_);
        return *this;
    }
private:
    Image* image_{};
};

如果 this == &rhs，delete image* 同时让 rhs.image* 指向已释放对象，下一行从 dangling pointer 复制。

即使不是 self-assignment，new Image 抛异常后 image_ 仍悬空，析构会再次 delete。

策略一：identity test

Bitmap& Bitmap::operator=(const Bitmap& rhs)
{
    if (this == &rhs)
        return *this;
 
    delete image_;
    image_ = new Image(*rhs.image_);
    return *this;
}

修复直接 self-assignment，却没有修复 new 抛异常后目标悬空。

上述实现甚至不满足 basic guarantee。identity test 只处理一个别名分支，不是完整资源提交策略。

identity test 的成本

地址比较通常很小，但如果实现本来能自然安全处理 self-assignment，就无需专门分支。是否保留应由语义和测量决定。

if (this != &rhs) {
    // expensive replacement
}
return *this;

通常比特殊分支更可靠。

策略二：先复制候选，再释放旧资源

Bitmap& Bitmap::operator=(const Bitmap& rhs)
{
    Image* candidate = new Image(*rhs.image_);
    delete image_;
    image_ = candidate;
    return *this;
}

self-assignment 时 candidate 在旧 image 仍有效时创建；分配失败时 this 完全没变。

该单资源实现满足强保证。若提交多成员可能抛，还需 no-throw commit 或更完整候选对象。

策略三：copy-and-swap

class Bitmap {
public:
    Bitmap& operator=(Bitmap rhs)
    {
        swap(rhs);
        return *this;
    }
 
    void swap(Bitmap& other) noexcept
    {
        using std::swap;
        swap(image_, other.image_);
    }
};

按值参数在函数体前 copy/move 构造候选；若失败 this 未变；swap 后旧资源由 rhs 析构。bitmap = bitmap 只是多复制一次，语义安全。

是 self-assignment 与异常安全共同解法。

rule of zero 消除手写风险

class Bitmap {
public:
    explicit Bitmap(Image image) : image_{std::move(image)} {}
private:
    Image image_;
};

如果 Image 是正确值类型，生成 assignment 组合其保证。优先重构 owning raw pointer，而不是不断加防护。

是生成复制自然安全的前提。

alias 不只发生在整个对象

Text& Text::operator=(std::string_view source)
{
    storage_.assign(source); // source 可能指向 storage_ 自身
    return *this;
}

即使 this 与 rhs 类型不同，source 也可能来自 text.view()。修改 storage_ 可先使 source 悬空。

Text& Text::operator=(std::string_view source)
{
    std::string candidate{source};
    storage_.swap(candidate);
    return *this;
}

更一般地，任何 source view 可能重叠目标表示时都先准备独立候选。

基类引用形成间接 self-assignment

Derived object;
Base& left = object;
Base& right = object;
left = right;

Base::operator= 应对自身 base subobject 安全。若 Derived assignment 先调用 Base::operator= 再复制成员，Item 12 还要求完整复制所有部分。

多重继承下地址可能有调整，不能用未经类型语义的 void* 比较替代稳健赋值。

self-move assignment

Buffer& Buffer::operator=(Buffer&& rhs) noexcept
{
    if (this != &rhs) {
        release();
        data_ = std::exchange(rhs.data_, nullptr);
        size_ = std::exchange(rhs.size_, 0);
    }
    return *this;
}

用户类型最好让 self-move 保持有效可析构状态；是否保持原值要文档化。guard 可保持值，swap-based move 也常自然安全。

copy-and-swap 的取舍

copy-and-swap 清晰但不总是最快：大对象可复用现有容量，成员逐项赋值可能更高效。优化版仍应先分配可能失败资源，再以 no-throw 操作提交。

Buffer& Buffer::assign(const Buffer& rhs)
{
    if (capacity_ < rhs.size_)
        return replace_with_candidate(rhs);
    copy_into_existing_storage(rhs); // 必须处理重叠或先检查身份
    size_ = rhs.size_;
    return *this;
}

必须用基准证明收益，并比 copy-and-swap 增加更多边界测试。

失败注入矩阵

先预测：delete-before-copy 在 self-assignment 时每一步的 image_ 指向什么；copy-before-delete 在 candidate 分配抛异常时目标值是什么。再运行 sanitizer 和资源计数。

• a = a、两个 pointer/reference alias、Base alias 都保持合法值。
• 子串 view 赋值先复制候选，不读取失效存储。
• 每个候选分配点抛异常时目标满足承诺保证。
• self-move 后对象可析构、可重新赋值且资源不重复释放。
• 返回引用地址始终为 this。
• 资源 create/destroy 计数在作用域结束后相等。

小结

• self-assignment 包括直接同名，也包括 pointer、reference、base 和 subobject alias
• delete-before-copy 会先摧毁源，并同时违反异常安全
• identity test 修复直接 self-assignment，但不能单独提供异常保证
• copy-before-delete 与 copy-and-swap 通过 prepare-then-commit 自然处理别名
• rule of zero 优先消除手写资源 assignment
• self-move 与跨类型 view 也要有明确有效状态和失败测试