Item 21：必须返回对象时，不要试图返回引用

从“省一次复制”的错误目标开始

假设 Rational 乘法产生一个新有理数：

class Rational {
public:
    Rational(int numerator = 0, int denominator = 1);
};
 
const Rational& operator*(const Rational& lhs, const Rational& rhs);

返回 reference 看似能避免复制，但问题先于性能：这个引用究竟绑定谁？结果既不是 lhs，也不是 rhs，而是一个必须拥有独立生命周期的新值。

Item 21 的原则是 Do not try to return a reference when you must return an object（必须返回对象时，不要试图返回引用）。

若语义要求新对象，就按值返回对象；不要为了猜测优化而虚构 owner。

返回局部对象引用会立即悬空

最直接的错误是返回 local object（局部对象）的引用：

const Rational& operator*(const Rational& lhs, const Rational& rhs) {
    Rational result(lhs.numerator() * rhs.numerator(),
                    lhs.denominator() * rhs.denominator());
    return result;
}

函数退出时 result destructor 执行，调用者得到 dangling reference（悬空引用）。后续读取已经结束生命周期的 storage 是 undefined behavior。

编译器警告不等于运行期保障。stack memory 可能暂时保留旧字节，让测试偶尔“正常”，随后被另一次调用覆盖。

返回 heap 引用会隐藏 ownership

有人把对象放到 heap，试图延长生命周期：

const Rational& operator*(const Rational& lhs, const Rational& rhs) {
    return *(new Rational(lhs.numerator() * rhs.numerator(),
                          lhs.denominator() * rhs.denominator()));
}

引用有效了，但调用语法 Rational product = a * b; 没有告诉用户需要 delete。更糟的是表达式 a * b * c 产生的中间引用没有可靠位置释放。

返回 unique_ptr<Rational> 虽能表达 ownership，但仍不符合普通乘法的 value semantics，并迫使每个算术表达式处理间接对象。只有结果本质是动态资源时才应返回 owner。

static 对象把结果变成共享槽位

第三种绕路是返回 function-local static：

const Rational& operator*(const Rational& lhs, const Rational& rhs) {
    static Rational result;
    result = Rational(lhs.numerator() * rhs.numerator(),
                      lhs.denominator() * rhs.denominator());
    return result;
}

对象不会析构过早，也没有每次泄漏，但所有调用共享同一个 result。const Rational& x = a*b; const Rational& y = c*d; 后，x 和 y 指向同一对象，第二次调用覆盖第一次结果。

线程安全初始化不等于线程安全修改；并发乘法会 data race。递归、重入和嵌套表达式同样破坏结果。

operator* 产生的是独立值

乘法操作符的自然语义是输入不变、产生新值。正确签名直接返回 Rational：

Rational operator*(const Rational& lhs, const Rational& rhs) {
    return Rational(lhs.numerator() * rhs.numerator(),
                    lhs.denominator() * rhs.denominator());
}

operator*（乘法操作符）按值返回，调用者可以自然组合、存储或丢弃结果，不承担 hidden delete，也不会与后续调用共享 identity。

让 copy elision 处理实现成本

现代 C++ 对许多 prvalue 返回保证 copy elision；即使未强制消除，编译器可做 NRVO，或使用 move constructor。

Rational multiply(Rational lhs, Rational rhs) {
    Rational result = normalize(lhs, rhs);
    return result; // NRVO candidate
}

不要写 return std::move(result) 企图帮助优化；它可能阻止 NRVO。先写正确 value semantics，再用 compiler、benchmark 与 profile 验证成本。

引用返回在借用既存对象时合理

规则不是“永远不返回引用”。assignment operator 返回 *this，container operator[] 返回既存 element，stream insertion 返回 stream；这些结果都已由其他对象拥有。

Widget& Widget::operator=(const Widget& rhs) {
    // replace state
    return *this;
}
 
const Item& Catalog::at(Index index) const {
    return items_.at(index);
}

关键是文档和类型能回答 owner、lifetime、invalidation 和 mutability。

Catalog 引用不能比 Catalog 活得久；vector 扩容可能让 element reference 失效；返回 non-const reference 还允许用户修改 invariant。

返回输入引用也要防临时对象

identity、min/max 风格函数可能返回某个输入引用：

const Record& chooseBetter(const Record& lhs, const Record& rhs);

若调用者传临时对象并把结果保存，临时在完整表达式末尾析构，引用悬空。

可通过 API 限制 rvalue overload、返回值、或使用语言 lifetime annotation/static analysis。不能只写一句“不要传临时值”就认为契约安全。

view 返回同样是 lifetime 契约

string_view、span、iterator range 按值返回描述符，但底层数据仍由其他对象拥有。

std::string_view User::displayName() const noexcept {
    return display_name_;
}

view 对象本身按值返回不会悬空，但 User 销毁或 string 被修改重分配后，底层引用失效。接口文档与测试必须覆盖 owner mutation。

可空与失败不应伪装成引用

C++ reference 不能合法表示“没有对象”。若查找可能无结果，可返回 pointer、optional value、optional reference wrapper、iterator 或 Result，按 ownership 选择。

std::optional<User> loadUser(UserId id);          // 独立 value
const User* findCachedUser(UserId id) noexcept;   // nullable borrow
Result<Document, LoadError> loadDocument(Path);   // value or error

返回 pointer 作为 borrow 时仍需说明 lifetime；返回 optional value 则由调用者拥有独立结果。

用地址与生命周期轨迹验证

先预测结果 storage 在每个 sequence point 后是否仍有 owner，再建立测试：

• compiler warnings 与 sanitizer 捕获 return-local-address 和 use-after-scope。
• allocation ledger 验证 operator 不产生无人负责的 heap object。
• 连续、嵌套、递归和多线程调用证明结果不共享 static slot。
• copy/move counters 与 compiler optimization report 验证 value return 成本。
• reference/view tests 覆盖 owner 销毁、container reallocation 和 mutation invalidation。
• temporary inputs 检查 input-bounded reference 不被保存。
• API static checks 确认 nullable/failed result 使用 pointer、optional 或 Result 表达。

正确性门禁先证明没有悬空、泄漏和共享覆盖，再讨论是否值得优化。

小结

• 新计算结果需要独立对象时，返回 reference 会制造错误 lifetime 或 ownership
• local object 引用立即悬空，heap 引用隐藏释放责任，static 引用共享并覆盖结果
• operator* 应按值返回 Rational，让 copy elision/NRVO 处理传递成本
• 返回引用只适用于借用既存对象，并明确 owner、invalidation、mutability 和输入 lifetime
• view、pointer、optional、Result 与 typed owner 各自表达不同返回契约
• return lifetime trace 应覆盖临时、嵌套、并发、重分配和失败路径