演算子オーバーロード — Add トレイトのサンプルコード — Rust

1Money + Money — 最小の Add 実装

impl Add for Money の add メソッドに「足す」の意味を書くと、Money 同士を + で足せるようになります。type Output = Money は + の結果の型の宣言です。金額のように足し算が自然な意味を持つ型では、メソッド呼び出しより式のほうが読みやすくなります。

Rust

use std::ops::Add;

struct Money {
    yen: i32,
}
impl Add for Money {
    type Output = Money; // + の結果の型
    fn add(self, other: Money) -> Money {
        Money { yen: self.yen + other.yen }
    }
}
fn main() {
    let total = Money { yen: 300 } + Money { yen: 450 };
    println!("合計 = {}円", total.yen);
}

2Add と Sub をそろえる

+ と - はそれぞれ独立したトレイト(Add と Sub)なので、使いたい演算子ごとに実装します。座標型に両方をそろえると、移動や差分の計算が数式のままの形で書けます。std::ops には Mul や Neg など、他の演算子に対応するトレイトも同じ形で揃っています。

Rust

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

struct Point { x: i32, y: i32 }
impl Add for Point {
    type Output = Point;
    fn add(self, o: Point) -> Point { Point { x: self.x + o.x, y: self.y + o.y } }
}
impl Sub for Point {
    type Output = Point;
    fn sub(self, o: Point) -> Point { Point { x: self.x - o.x, y: self.y - o.y } }
}
fn main() {
    let sum = Point { x: 5, y: 7 } + Point { x: 1, y: 2 };
    let diff = Point { x: 5, y: 7 } - Point { x: 1, y: 2 };
    println!("sum = ({}, {})", sum.x, sum.y);
    println!("diff = ({}, {})", diff.x, diff.y);
}

3右辺の型を変える — Add<i32>

Add<i32> のように型パラメータを指定すると、「Money + i32」という左右で型が違う足し算を定義できます。何も指定しない impl Add は「同じ型同士の足し算」の省略形だった、という関係です。金額に手数料の数値を直接足すような、単位が文脈から明らかな場面で便利です。

Rust

use std::ops::Add;

struct Money {
    yen: i32,
}
// Add<i32> で「Money + i32」という組み合わせを定義する
impl Add<i32> for Money {
    type Output = Money;
    fn add(self, amount: i32) -> Money {
        Money { yen: self.yen + amount }
    }
}
fn main() {
    let price = Money { yen: 1000 };
    let with_fee = price + 250; // 右辺は i32 のまま書ける
    println!("手数料込み = {}円", with_fee.yen);
}

4Copy と組み合わせて使い回す

add は self を値で受け取るため、そのままでは + を使うたびに両辺がムーブされます。#[derive(Clone, Copy)] を付ければ複製が渡されるようになり、ループの中で pos = pos + m と繰り返し足せます。小さな数値だけでできた型に Copy を付けるのは、演算子オーバーロードの定番の組み合わせです。

Rust

use std::ops::Add;

#[derive(Clone, Copy)]
struct Vec2 { x: f64, y: f64 }
impl Add for Vec2 {
    type Output = Vec2;
    fn add(self, o: Vec2) -> Vec2 { Vec2 { x: self.x + o.x, y: self.y + o.y } }
}
fn main() {
    let moves = [
        Vec2 { x: 1.0, y: 0.0 },
        Vec2 { x: 0.0, y: 2.0 },
        Vec2 { x: 3.0, y: 1.0 },
    ];
    let mut pos = Vec2 { x: 0.0, y: 0.0 };
    for m in moves {
        pos = pos + m; // Copy なのでムーブされず何度でも足せる
    }
    println!("最終位置 = ({}, {})", pos.x, pos.y);
}

5ベクトル演算 — pos + velocity * dt

Add(ベクトル同士の加算)と Mul<f64>(スカラー倍)をそろえると、物理シミュレーションの位置更新が数式とほぼ同じ形で書けます。式全体の意図が一目で伝わるのが、ゲームやグラフィックスのコードでベクトル型に演算子を実装する理由です。直感に合う演算だけに使う、という鉄則はここでも同じです。

Rust

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

#[derive(Clone, Copy)]
struct Vec2 { x: f64, y: f64 }
impl Add for Vec2 {
    type Output = Vec2;
    fn add(self, o: Vec2) -> Vec2 { Vec2 { x: self.x + o.x, y: self.y + o.y } }
}
// Mul<f64> で「ベクトル × スカラー」を定義する
impl Mul<f64> for Vec2 {
    type Output = Vec2;
    fn mul(self, k: f64) -> Vec2 { Vec2 { x: self.x * k, y: self.y * k } }
}
fn main() {
    let pos = Vec2 { x: 10.0, y: 5.0 };
    let velocity = Vec2 { x: 2.0, y: -1.0 };
    let dt = 0.5;
    let next = pos + velocity * dt; // 数式と同じ形で書ける
    println!("次の位置 = ({}, {})", next.x, next.y);
}

サンプルコードで身につける: 演算子オーバーロード — Add トレイト

1Money + Money — 最小の Add 実装

2Add と Sub をそろえる

3右辺の型を変える — Add<i32>

4Copy と組み合わせて使い回す

5ベクトル演算 — pos + velocity * dt