目录
1，结构体、成员方法
2，trait（特征）
3，同名函数的覆盖、冲突
4，trait继承
5，trait的孤儿规则
6，trait的type成员
给结构体添加方法有2种，一种是直接实现，一种的带trait的实现。
直接实现的方式中，数据和方法是对应的。带trait的实现中，trait是一组可以被共享的行为，只要实现了特征，你就能使用这组行为。
1，结构体、成员方法
struct SearchData{
}
impl SearchData{
fn f(&self)-> i32{
return 123;
}
fn f2()-> i32{
return 456;
}
}
fn main() {
let x=SearchData{};
assert_eq!(x.f(), 123);
assert_eq!(SearchData::f2(), 456);
}
2，trait（特征）
带trait的实现方式中，数据、接口描述、接口实现要分开。
trait Solution{
fn find(&self)-> i32;
}
struct SearchData{
}
impl Solution for SearchData{
fn find(&self)-> i32{
return 123;
}
}
fn main() {
let x=SearchData{};
println!("{}",x.find());
}
3，同名函数的覆盖、冲突
直接实现的方法会覆盖trait中的方法
：
struct SearchData{
}
impl SearchData{
fn f1(&self)-> i32{
return 100;
}
fn f2(&self)-> i32{
return 222;
}
}
trait S{
fn f1(&self)-> i32;
fn f3(&self)-> i32;
}
impl S for SearchData{
fn f1(&self)-> i32{
return 111;
}
fn f3(&self)-> i32{
return 333;
}
}
fn main() {
let x=SearchData{};
println!("{} {} {}",x.f1(),x.f2(),x.f3());
}
输出：100 222 333
也就是说，代码可以正常运行，类型中非函数会覆盖trait中的同名函数。
被覆盖的函数也不是完全无法调用，只是不能用最简单的写法去调用，调用方法：
struct SearchData{
}
impl SearchData{
fn f1(&self)-> i32{
return 100;
}
fn f2()->i32{
return 222;
}
}
trait S{
fn f1(&self)-> i32;
fn f2()->i32;
}
impl S for SearchData{
fn f1(&self)-> i32{
return 111;
}
fn f2()->i32{
return 333;
}
}
fn main() {
let x=SearchData{};
println!("{} {}",x.f1(),S::f1(&x));
println!("{} {}",SearchData::f2(),<SearchData as S>::f2());
}
带self参数的，用S::f1方式去调用，不带self的，用<SearchData as S>::f2调用，相当于把具体的SearchData 类型向上转换成抽象的S类型之后再调用。
trait的具体实现会覆盖默认实现
：
struct SearchData{
}
trait S{
fn f1(&self)-> i32{
return 222;
}
}
impl S for SearchData{
fn f1(&self)-> i32{
return 333;
}
}
fn main() {
let x=SearchData{};
println!("{}",x.f1());
}
输出333
2个trait之间的同名函数会冲突，造成编译失败
：
struct SearchData{
}
trait S{
fn f1(&self)-> i32;
}
impl S for SearchData{
fn f1(&self)-> i32{
return 111;
}
}
trait S2:S{
fn f1(&self)-> i32;
}
impl S2 for SearchData{
fn f1(&self)-> i32{
return 222;
}
}
fn main() {
let x=SearchData{};
println!("{}",x.f1());
}
4，trait继承
trait A{
fn funa();
}
trait B:A{
fn funb();
}
trait C:A+B{
fn func();
}
struct S{
}
impl A for S{
fn funa(){
println!("run a");
}
}
impl B for S{
fn funb(){
println!("run b");
}
}
impl C for S{
fn func(){
S::funa();
println!("run c");
}
}
注意，虽然有继承关系，但是
可见性却是平级的，父特征中的方法也可以调用子特征中的方法
。
例如，自定义排序是这么写的：
#[derive(Eq,PartialEq)]
struct Node{
id:i32,
num:i32
}
impl Ord for Node {
#[inline]
fn cmp(&self, other: &Node) -> Ordering {
if self.num != other.num{
return (*other).num.cmp(&self.num);
}else{
return self.id.cmp(&(*other).id);
}
}
}
impl PartialOrd for Node{
fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
return Some(self.cmp(other));
}
}
Ord依赖PartialOrd，但实现上却建议用partial_cmp调用cmp。
我是这么理解的，
trait继承表达的是顶层的依赖关系，即设计层面的依赖关系，而trait内的函数调用是底层的依赖关系，即实现层面的依赖关系
。
5，trait的孤儿规则
孤儿规则：如果你想要为类型 A 实现特征 T，那么 A 或者 T 至少有一个是在当前作用域中定义的。
这条规则保证了代码的安全性，使得无关的代码不会互相影响。
6，trait的type成员
以减法为例
pub trait Sub<Rhs = Self> {
type Output;
fn sub(self, rhs: Rhs) -> Self::Output;
}
用法：
struct S{
x:i32,
y:f32
}
impl Sub for S{
type Output = Self;
fn sub(self,rhs:Self)->Self::Output{
S{x:self.x-rhs.x,y:self.y-rhs.y}
}
}
