为不同类型参数实现std::ops::Add并规避无效运算

要实现你需要的类型加法规则，核心是利用Rust中std::ops::Add trait的**泛型右操作数（RHS）**特性——默认情况下Add的右操作数是Self，但我们可以显式指定其他类型作为右操作数，从而为不同的类型组合实现加法逻辑，同时故意不为无意义的组合提供实现，触发编译错误。

步骤1：定义基础类型 #

首先定义Position（位置）和Displacement（位移）两个结构体，这里用二维坐标作为示例：

#[derive(Debug, Clone, Copy, PartialEq)]
struct Position {
    x: f64,
    y: f64,
}

#[derive(Debug, Clone, Copy, PartialEq)]
struct Displacement {
    dx: f64,
    dy: f64,
}

步骤2：为类型实现Add trait #

根据需求，我们需要实现两种加法组合：

1. Position + Displacement → Position

为Position实现Add<Displacement>，指定关联类型Output为Position：

use std::ops::Add;

impl Add<Displacement> for Position {
    type Output = Position;

    fn add(self, other: Displacement) -> Self::Output {
        Position {
            x: self.x + other.dx,
            y: self.y + other.dy,
        }
    }
}

2. Displacement + Displacement → Displacement

为Displacement实现Add<Displacement>（这里右操作数是自身，符合默认情况）：

impl Add for Displacement {
    type Output = Displacement;

    fn add(self, other: Self) -> Self::Output {
        Displacement {
            dx: self.dx + other.dx,
            dy: self.dy + other.dy,
        }
    }
}

步骤3：验证效果 #

现在测试合法和非法的加法操作：

fn main() {
    // 合法操作：Position + Displacement
    let pos = Position { x: 1.0, y: 2.0 };
    let disp = Displacement { dx: 3.0, dy: 4.0 };
    let new_pos = pos + disp;
    assert_eq!(new_pos, Position { x: 4.0, y: 6.0 });

    // 合法操作：Displacement + Displacement
    let disp1 = Displacement { dx: 1.0, dy: 2.0 };
    let disp2 = Displacement { dx: 3.0, dy: 4.0 };
    let total_disp = disp1 + disp2;
    assert_eq!(total_disp, Displacement { dx: 4.0, dy: 6.0 });

    // 非法操作：Position + Position（编译时会报错）
    // let pos1 = Position { x: 1.0, y: 2.0 };
    // let pos2 = Position { x: 3.0, y: 4.0 };
    // let invalid = pos1 + pos2; // 编译错误：cannot add `Position` to `Position`
}

关键原理说明 #

• Add trait的定义允许指定泛型参数RHS（默认是Self），因此我们可以为Self和不同的RHS类型组合实现加法逻辑。
• 对于Position + Position这种无意义操作，我们不提供任何Add<Position>的实现，Rust编译器会在尝试编译这类代码时抛出错误，完全符合你的需求。

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