More effective C++:效率（2）

Item M21：通过重载避免隐式类型转换

通过函数重载来避免隐式类型转换带来的性能开销。当一个用户自定义类型（如 UPInt）与一个基本类型（如 int）一起使用算术运算符（如 +）时，C++ 编译器会尝试通过创建临时对象来进行隐式类型转换，以便能够调用相应的运算符重载函数。虽然这使得编程更加方便，但同时也带来了不必要的性能开销，因为每次都需要创建临时对象。

为了避免这种开销，建议显式地为不同类型的参数重载运算符。例如，对于 UPInt 类，可以重载 operator+ 以接受一个 UPInt 和一个 int 作为参数，或者两个 UPInt 作为参数。这样做可以让编译器直接选择正确的重载版本，而不是创建临时对象来匹配已有的重载版本。

class UPInt { // 无限精度整数类
public:
    UPInt();
    UPInt(int value);
    // 其他成员函数...
};

// 重载运算符以支持不同类型的参数
const UPInt operator+(const UPInt& lhs, const UPInt& rhs); // 加两个 UPInt
const UPInt operator+(const UPInt& lhs, int rhs);           // 加一个 UPInt 和一个 int
const UPInt operator+(int lhs, const UPInt& rhs);           // 加一个 int 和一个 UPInt
// 示例使用
UPInt upi1, upi2;
UPInt upi3 = upi1 + upi2; // 直接调用两个 UPInt 参数的重载
upi3 = upi1 + 10;         // 直接调用一个 UPInt 和一个 int 参数的重载
upi3 = 10 + upi2;         // 直接调用一个 int 和一个 UPInt 参数的重载

作者强调了一个重要的点，即不应该重载只有基本类型参数的运算符，如 const UPInt operator+(int lhs, int rhs);，因为 C++ 规定每个重载的运算符至少需要一个用户定义类型的参数。这是因为如果允许对基本类型重载运算符，可能会导致预定义行为的意外改变，进而引发程序错误。

如果允许程序员重载这些基本类型的运算符，那么就有可能改变这些基本类型的默认行为。如果允许重载 int + int，那么 2 + 2 可能不再等于 4，而是其他值，这会导致程序行为不可预测。

Item M22：考虑用运算符的赋值形式（op=）取代其单独形式（op）

整理后的代码及解释

1. 定义 Rational 类

首先，定义一个简单的 Rational 类，用于表示有理数，并实现 operator+= 和 operator-=：

class Rational {
public:
    Rational(int numerator = 0, int denominator = 1) : num(numerator), den(denominator) {
        if (den == 0) {
            throw std::invalid_argument("Denominator cannot be zero");
        }
        normalize();
    }
    Rational& operator+=(const Rational& rhs) {
        num = num * rhs.den + rhs.num * den;
        den *= rhs.den;
        normalize();
        return *this;
    }
    Rational& operator-=(const Rational& rhs) {
        num = num * rhs.den - rhs.num * den;
        den *= rhs.den;
        normalize();
        return *this;
    }
private:
    void normalize() {
        int gcd = std::gcd(num, den);
        num /= gcd;
        den /= gcd;
    }
    int num; // 分子
    int den; // 分母
};

2. 实现 operator+ 和 operator- 通过 operator+= 和 operator-=

接下来，通过 operator+= 和 operator-= 来实现 operator+ 和 operator-：

const Rational operator+(const Rational& lhs, const Rational& rhs) {
    return Rational(lhs) += rhs;
}
const Rational operator-(const Rational& lhs, const Rational& rhs) {
    return Rational(lhs) -= rhs;
}

3. 使用模板实现通用的 operator+ 和 operator-

为了进一步简化代码，可以使用模板来实现通用的 operator+ 和 operator-：

template<class T>
const T operator+(const T& lhs, const T& rhs) {
    return T(lhs) += rhs;
}
template<class T>
const T operator-(const T& lhs, const T& rhs) {
    return T(lhs) -= rhs;
}

效率：operator+= 和 operator-= 是赋值运算符，它们直接在左操作数上进行操作，不需要创建临时对象。这使得它们比单独的 operator+ 和 operator- 更高效。

代码复用：通过 operator+= 和 operator-= 来实现 operator+ 和 operator-，可以减少代码重复，只需要维护 operator+= 和 operator-=。

避免临时对象：operator+ 和 operator- 通过创建临时对象来调用 operator+= 和 operator-=，但这仍然是一个高效的实现方式，因为临时对象的创建和销毁开销相对较小。

临时对象：operator+ 和 operator- 会创建临时对象，这可能会带来一些开销。但是，现代编译器通常会进行返回值优化（RVO），减少临时对象的创建和销毁开销。

使用未命名的临时对象（如 return T(lhs) += rhs;）通常比命名对象（如 T result(lhs); return result += rhs;）更高效，因为未命名对象更容易被编译器优化。

通过实现 operator+= 和 operator-=，并利用这些赋值运算符来实现 operator+ 和 operator-，可以确保代码的高效性和一致性

Item M23：考虑变更程序库

理想的程序库应该是短小、快速、强大、灵活、可扩展、直观、普遍适用、有良好支持、没有使用约束、没有错误的。但现实中不可能同时具备所有这些特性。不同的设计者会对这些特性赋予不同的优先级，因此即使是提供相同功能的程序库，其性能特征也可能完全不同。

iostream 和 stdio 的比较：

类型安全和可扩展性：iostream 是类型安全的，支持面向对象的扩展，而 stdio 则不具备这些特性。

性能：stdio 通常在执行速度和生成的执行文件大小上优于 iostream。作者通过一个基准测试（benchmark）程序验证了这一点，结果显示 stdio 在大多数情况下更快，有时甚至快很多。

代码实现：stdio 的高效性主要来自于其代码实现，特别是在运行时解析格式字符串的方式。而 iostream 在编译时确定操作数的类型，理论上可以更高效，但实际表现取决于具体的实现。

性能优化：

一旦找到软件的瓶颈（通过性能分析工具如 profiler），可以考虑更换程序库来消除瓶颈。例如，如果程序有 I/O 瓶颈，可以考虑用 stdio 替代 iostream；如果程序在动态内存分配和释放上花费大量时间，可以考虑使用其他 operator new 和 operator delete 的实现。