Rust中实现Polynomial类型重载运算符时如何实现自动借用？

这个需求太合理了——谁也不想写一堆&把表达式搞得乱七八糟。其实在Rust里完全可以实现这种“自动借用”的运算符行为，核心思路是覆盖所有可能的操作数组合（值、引用的各种搭配），让编译器自动帮你做引用转换，不用手动加&。

1. 为运算符实现多组impl #

你已经写了&Polynomial之间的运算符重载，现在只需要补充另外三组组合的impl，就能支持任意值和引用的混合运算：

比如以加法为例：

use std::ops::{Add, Sub, Mul};

// 你已经实现的引用版本
impl Add for &Polynomial {
    type Output = Polynomial;
    fn add(self, other: Self) -> Polynomial {
        let mut result = self.clone();
        for (power, coeff) in other.coefficients.iter().enumerate() {
            result.add_coeff(power, *coeff);
        }
        result
    }
}

// 补充：值 + 值
impl Add for Polynomial {
    type Output = Polynomial;
    fn add(self, other: Self) -> Self::Output {
        &self + &other // 直接复用引用版本的实现，避免重复代码
    }
}

// 补充：值 + 引用
impl Add<&Polynomial> for Polynomial {
    type Output = Polynomial;
    fn add(self, other: &Polynomial) -> Self::Output {
        &self + other // 复用引用版本
    }
}

// 补充：引用 + 值
impl Add<Polynomial> for &Polynomial {
    type Output = Polynomial;
    fn add(self, other: Polynomial) -> Self::Output {
        self + &other // 复用引用版本
    }
}

减法、乘法等运算符都可以照这个模式补充，这样不管你写a + b、&a + b还是a + &b，编译器都会自动匹配到对应的impl，不用手动写一堆&了。

2. 用宏减少重复代码 #

如果要实现加减乘除好几个运算符，写四组impl会非常繁琐。这时候可以用Rust的宏来批量生成代码，大大减少重复劳动：

macro_rules! impl_op_for_all_ref_combinations {
    // 定义宏：接收运算符trait和方法名（比如Add和add）
    ($trait:ident, $method:ident) => {
        // 值 + 值
        impl $trait for Polynomial {
            type Output = Polynomial;
            fn $method(self, other: Self) -> Self::Output {
                &self.$method(&other)
            }
        }

        // 值 + 引用
        impl $trait<&Polynomial> for Polynomial {
            type Output = Polynomial;
            fn $method(self, other: &Polynomial) -> Self::Output {
                &self.$method(other)
            }
        }

        // 引用 + 值
        impl $trait<Polynomial> for &Polynomial {
            type Output = Polynomial;
            fn $method(self, other: Polynomial) -> Self::Output {
                self.$method(&other)
            }
        }
    };
}

// 批量生成加法、减法、乘法的多组impl
impl_op_for_all_ref_combinations!(Add, add);
impl_op_for_all_ref_combinations!(Sub, sub);
impl_op_for_all_ref_combinations!(Mul, mul);

这样只需要写一次宏，就能给所有需要的运算符生成完整的impl组合，代码瞬间清爽很多。

3. 原理说明 #

Rust编译器会自动进行自动引用和解引用强制转换：当你写a + b时，如果a是Polynomial值，编译器会自动将其转换为&Polynomial去匹配对应的impl，就像调用方法时a.method()会自动转为(&a).method()一样。通过覆盖所有值和引用的组合，我们给编译器提供了足够的“选项”，让它总能找到合适的重载实现。

效果验证 #

现在你就能像期望的那样写简洁的表达式了：

// 无需任何手动&，代码可读性拉满
assert_eq!(quotient * p1 + remainder, p2);
let result = (a * b + c * d) / 2;

内容的提问来源于stack exchange，提问作者Jor