c++ - Rust 中不止一个运算符重载

Question

我知道通过使用特征在 Rust 中实现运算符重载是可能的。在 C++ 中，对于相同的运算符和相同的 struct 也可能有多个运算符重载。 ，并打开/关闭要使用的运算符。
是否可以在 Rust 中执行与以下 C++ 代码相同的操作？可能在同一个源文件中？

struct S
{
    int value;
};

namespace first
{
S operator+(S lhs, S rhs)
{
    return S{ lhs.value + rhs.value };
}
}

namespace second
{
S operator+(S lhs, S rhs)
{
    return S{ lhs.value * rhs.value };
}
}

int main()
{
    S s1{5};
    S s2{10};
    {
        using namespace first;
        S s3 = s1 + s2;
        std::cout << s3.value << std::endl;
    }
    {
        using namespace second;
        S s3 = s1 + s2;
        std::cout << s3.value << std::endl;
    }
}

Answer 1

Is it possible to do the same as the following C++ code in Rust?Possibly in the same source file?

不，它不是(不完全是)出于以下原因:

一个结构不能两次实现相同的特征(你为什么要那样做？)

Rust 中没有函数重载

关于你想要的代码，你可以像这样近似:

#[derive(Debug)]
struct S(i32);

mod first {
    use crate::S;
    pub trait Foo {
        fn bar(self, s: S) -> S;
    }
    
    impl Foo for S  {
        fn bar(self, s: S) -> S {
            S(self.0 + s.0)
        }
    }
}

mod second {
    use crate::S;
    pub trait Foo {
        fn bar(self, s: S) -> S;
    }
    
    impl Foo for S  {
        fn bar(self, s: S) -> S {
            S(self.0 * s.0)
        }
    }
}

fn main() {
    let first_res = first::Foo::bar(S(1), S(2));
    let second_res = second::Foo::bar(S(1), S(2));

    println!("{:?}, {:?}", first_res, second_res);
    
    {
        use first::Foo;
        println!("{:?}", S(1).bar(S(2)));
    }
    
    {
        use second::Foo;
        println!("{:?}", S(1).bar(S(2)));
    }
}

Playground
请注意 Foo对于编译器来说，traits 确实是不同的 trait。因此，您正在实现两种不同的特征，而不是一种。出于同样的原因， bar方法也是不同的。