一、前言
為通用類型賦予一個默認的類型，大部分的語言是沒有這個特性的，但是也有例外的，例如TypeScript（可能還有其它）。
例如TypeScript可以這樣使用：
class MyClass<T = number> {
value: T;
constructor(value: T) {
this.value = value;
}
printValue(): void {
console.log(`Value is ${this.value}`);
}
}
const obj1 = new MyClass(42); // 使用默認類型 number
const obj2 = new MyClass<string>("Hello"); // 使用指定類型 string而運算符重載，則不少語言也支持，最典型的莫過於C++，C#.
但是rust的運算符重載是比較特別的一種，該怎麼説了？
rustc做了太多的工作，而且我覺得有點違背一些通用的設計規則。這是因為例子中的方法必須要求對象實現Copy，但是方法的參數又沒有帶&，會讓人誤會！
不喜歡有太多默認約定的設計，更喜歡每個東西都明明白白地定義。
二、通用類型參數默認類型
讀取來有點拗口，意思就是:
1.在有關對象(struc,特質等）或者方法中使用通用參數T
2.可以為T指定一個默認的類型，語法是T=xxx,其中xxx是某個具體類型
如果你不喜歡T，也可以換成任意合法的rust標識符.
就目前來看，通用參數的默認參數的作用有兩點：運算符重載+方便
三、運算符重載和其它作用
3.1、運算符重載
所謂運算符重載就是除了運算符最原始的功能（編譯器默認支持的）之外，還可以支持其它類型的運算數。
例如+通常用於整數、浮點數等的相加，但通過重載，其它類型對象實例也可以使用+。
以此類推，-*/等運算符號也可以。
不管怎麼説，這算是一個好東西！
只不過類型參數的默認類型好像就是為了運算符重載而存在。
3.2、其它作用
查了一些資料，據説可以結合條件編譯。其它作用就是無關緊要的。
條件編譯示例
// 定義一個特性標誌，用於條件編譯
#[cfg(feature = "use_f64")]
type DefaultNumType = f64;
#[cfg(not(feature = "use_f64"))]
type DefaultNumType = i32;
struct Point<T = DefaultNumType> {
x: T,
y: T,
}
impl<T> Point<T> {
fn new(x: T, y: T) -> Self {
Point { x, y }
}
}
四、示例
4.1、示例代碼
由於例子涉及到Add，Sub兩個特質，所以先列出此二特質的定義：
pub trait Add<Rhs = Self> {
type Output;
fn add(self, rhs: Rhs) -> Self::Output;
}
pub trait Sub<Rhs = Self> {
type Output;
fn sub(self, rhs: Rhs) -> Self::Output;
}對書本上的例子稍微改造了下：
use std::ops::{Add,Sub};
#[derive(Debug, Copy, Clone, PartialEq)]
struct Point {
x: i32,
y: i32,
}
/**
* 這個使用默認類型，來自rust編程語言官方文檔的例子
*/
impl Add for Point {
type Output = Point;
fn add(self, other: Point) -> Point {
Point {
x: self.x + other.x,
y: self.y + other.y,
}
}
}
/**
* 實現相減運算符（從而實現Point的-重載)，需要實現Sub trait
*/
impl Sub for Point {
type Output = Point;
/**
* 需要特別注意的是兩個參數的定義
* self - 沒有使用引用
* other - 沒有要求引用
* 這種不引用的方式，不同於一般的方法定義
*/
fn sub(self, other: Point) -> Point {
Point {
x: self.x - other.x,
y: self.y - other.y,
}
}
}
fn main() {
let p1 = Point { x: 1, y: 2 };
let p2 = Point { x: 3, y: 4 };
//使用重載的方式調用
println!("{:?}+{:?}={:?}",p1,p2, p1 + p2);
println!("{:?}-{:?}={:?}",p1,p2, p1 - p2);
//不使用重載的方式調用
let p3 = p1.add(p2).sub(p2);
let p4 = (p1.sub(p2)).add(p2);
println!("{:?}+{:?}-{:?}={:?}",p1,p2, p2,p3);
println!("{:?}-{:?}+{:?}={:?}",p1,p2,p2, p4);
let lml= Person {name: "lml".to_string()};
let ww= Animal {name: "ww".to_string()};
lml.attack(ww);
println!("{:?}",lml);
}
// --------------------------------------------------------
// 以下的代碼是為了演示 參數不帶&是什麼情況
trait Fight {
type Item;
//fn attack(&self, other: &Self::Item);
fn attack(self, other: Self::Item);
}
#[derive(Debug)]
struct Person {name: String}
#[derive(Debug)]
struct Animal {name: String}
impl Fight for Person {
type Item = Animal;
fn attack(self, other: Self::Item) {
println!(
"{}攻擊了{}",
self.name,
other.name
);
}
}這個例子做了三件事情：
1.重載+
2.重載-
3.如果不使用Copy特質會怎麼樣
特質Fight和結構體Person，Animal就是為了驗證第3點。
4.2、名詞解釋
在開始執行代碼前，先解釋兩個重要的內容
Rhs
Rhs是 "Right-Hand Side"（右側操作數）的縮寫
關鍵字self和Self
仔細看看，才發現是兩個，不是一個，要知道rust中是區分大小寫的。
self-全小寫，表示對象實例本身
Self-首字母大寫，其它小寫，表示類型本身
例如以下代碼中：
在方法attack中，第一個self表示具體對象實例，第二個Self則表示具體對象類型。
pub trait Add<Rhs = Self> {
type Output;
fn add(self, rhs: Rhs) -> Self::Output;
}
pub trait Sub<Rhs = Self> {
type Output;
fn sub(self, rhs: Rhs) -> Self::Output;
}現在代碼應該容易看了。
4.3、執行
看看輸出：
只要把示例中如下一部分：
trait Fight {
type Item;
//fn attack(&self, other: &Self::Item);
fn attack(self, other: Self::Item);
}
#[derive(Debug)]
struct Person {name: String}
#[derive(Debug)]
struct Animal {name: String}
impl Fight for Person {
type Item = Animal;
fn attack(self, other: Self::Item) {
println!(
"{}攻擊了{}",
self.name,
other.name
);
}
}修改為：
trait Fight {
type Item;
fn attack(&self, other: &Self::Item);
//fn attack(self, other: Self::Item);
}
#[derive(Debug)]
struct Person {name: String}
#[derive(Debug)]
struct Animal {name: String}
impl Fight for Person {
type Item = Animal;
fn attack(&self, other: &Self::Item) {
println!(
"{}攻擊了{}",
self.name,
other.name
);
}
}再把main的調用修改為:
那麼就可以正確輸出：
為什麼在Point上沒有這個問題了？這是因為Point實現了Copy特質,看下面的代碼：#[derive(Debug, Copy, Clone, PartialEq)]
rust的Copy特質奇怪的作用：允許類型進行隱式的、按位的複製，適用於簡單數據類型，避免不必要的所有權移動，提升代碼效率和便利性。同時，強調其使用條件和限制，幫助用户正確理解和應用
什麼是按位複製？
也就是説，當賦值或作為函數參數傳遞時，不需要移動所有權，而是直接複製。不過，只有滿足某些條件的類型才能實現Copy，比如所有字段都實現了Copy，並且類型本身沒有實現Drop trait
所以，上例中，即使在方法中沒有定義為引用類型，它也不會報錯。而Person並沒有實現Copy特質，所以會發生這個問題。
五、示例2
以下的示例演示了一個只包含字符串切片的struct如何相加
use std::ops::Add;
#[derive(Debug,Clone,Copy)]
struct Name<'a>{
name:&'a str
}
impl<'a> Add for Name<'a>{
type Output = Name<'a>;
fn add(self, other: Self) -> Self {
let tmp=format!("{} {}",self.name,other.name);
//Box::leak的作用是 將堆上的內存轉換為 'static 生命週期的引用
let leaked_str: &'static str = Box::leak(tmp.into_boxed_str());
Self{name: leaked_str }
}
}
fn main() {
let name1 = Name{name:"lu"};
let name2 = Name{name:" mula"};
let name3=name1+name2;
println!("name1={:?},name2={:?}", name1,name2);
println!("name3={:?}", name3);
let name4=String::from("lu");
let name5=String::from("lu");
let name6=add(name4,name5);
println!("name6={:?}", name6);
}
fn add(name1:String,name2:String)->String{
format!("{} {}",name1,name2)
}運行結果：
本例主要説明以下幾個問題：
1.字符串切片可以Copy.所以包含字符串切片的類型也可以實現+等重載
2.實現和字符串切片有關的內容太麻煩，導出是奇怪的生命週期符號
六、小結
1.rust通過定義通用類型參數的默認類型來實現運算符重載
2.但也不是什麼對象都可以重載，最好是能夠實現Copy特質的類型，否則可能失敗
