Как реализовать трейт Add для ссылки на структуру в Rust?

Проблема времени жизни (lifetime) при реализации трейта для ссылок

Ваша проблема типична для начинающих Rust-разработчиков. Когда вы реализуете трейт для ссылочного типа, компилятору необходимо знать, как долго живут ссылки, чтобы гарантировать безопасность памяти. В вашем случае, impl std::ops::Add for &Point — это неполная запись, так как &Point на самом деле является сокращением для &'a Point, где 'a — время жизни ссылки.

Вот правильная реализация:

use std::ops::Add;

#[derive(Debug, Clone, Copy)]
struct Point {
    x: i32,
    y: i32,
}

// Реализация Add для ссылок на Point с одинаковым временем жизни
impl<'a> Add for &'a Point {
    type Output = Point;

    fn add(self, other: &'a Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

fn main() {
    let a = Point { x: 1, y: 2 };
    let b = Point { x: 3, y: 4 };
    let c = &a + &b; // Теперь работает!
    println!("c = ({}, {})", c.x, c.y); // Выведет: c = (4, 6)
}

Подробное объяснение

• Параметр времени жизни 'a: Мы объявляем обобщённое время жизни 'a с помощью impl<'a>. Это означает, что реализация трейта действительна для любого конкретного времени жизни 'a.
• for &'a Point: Мы реализуем трейт для типа &'a Point — ссылки на Point, которая живёт как минимум 'a.
• Параметры метода add: self имеет тип &'a Point, а other — тоже &'a Point. Компилятор видит, что обе ссылки имеют одинаковое время жизни, и это безопасно.
• type Output = Point: Результат сложения — это новый экземпляр Point, а не ссылка. Это логично, потому что мы не можем вернуть ссылку на локально созданный объект.

Что делать, если ссылки имеют разные времена жизни?

Если вы хотите складывать ссылки с разными временами жизни, нужно использовать два параметра времени жизни:

impl<'a, 'b> Add<&'b Point> for &'a Point {
    type Output = Point;

    fn add(self, other: &'b Point) -> Point {
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

Здесь 'a — время жизни левой ссылки (self), а 'b — время жизни правой ссылки (other). Компилятор сам проверит, что обе ссылки живы на момент вызова.

Важные замечания

• Автоматическое копирование: Если ваша структура реализует Copy (как в примере с i32), то можно просто складывать по значению. Но если структура содержит, например, String или Vec, то передача по ссылке — правильный выбор.
• Удобство использования: После реализации Add for &Point вы можете складывать как ссылки (&a + &b), так и значения (a + b), если также реализовали Add for Point. Rust сам выберет нужную перегрузку.

use std::ops::Add;
use std::borrow::Borrow;

#[derive(Debug, Clone)]
struct Point {
    x: i32,
    y: i32,
}

// Обобщённая реализация, которая принимает всё, что можно заимствовать как Point
impl> Add for Point {
    type Output = Point;

    fn add(self, other: T) -> Point {
        let other = other.borrow();
        Point {
            x: self.x + other.x,
            y: self.y + other.y,
        }
    }
}

fn main() {
    let a = Point { x: 1, y: 2 };
    let b = Point { x: 3, y: 4 };
    let c = a + &b; // Работает: a по значению, b по ссылке
    println!("c = ({}, {})", c.x, c.y); // Выведет: c = (4, 6)
}