1、struct 成员变量与成员方法分离
eg1
// 结构体的【成员变量】
struct Foo {
age: i32,
name: String,
}
// 结构体的【成员方法】
impl Foo {
fn show(&self) {
println!("age = {:?}, name = {:?}", self.age, self.name);
}
}
fn main()
{
let f = Foo {age:99, name:String::from("xiong")};
f.show();
}
➜ main make
rustc main.rs
./main
age = 99, name = "xiong"
➜ main
eg2
struct Circle {
x: f64,
y: f64,
radius: f64,
}
/**
* impl关键字在struct、enum或者trait对象上实现方法调用语法
* 关联函数 (associated function) 的第一个参数通常为self参数。
*
* 有3种变体：
* => self，允许实现者移动和修改对象，对应的闭包特性为FnOnce
* => &self，既不允许实现者移动对象也不允许修改，对应的闭包特性为Fn
* => &mut self，允许实现者修改对象但不允许移动，对应的闭包特性为FnMut
* => 不含self参数的关联函数称为静态方法 (static method)
*/
impl Circle {
/**
* 相当于类方法 => Circle::new() 调用
*/
fn new(x: f64, y: f64, radius: f64) -> Circle {
// 创建Circle对象，省去return
Circle {
x: x,
y: y,
radius: radius,
}
}
/**
* 相当于实例方法 => Circle对象.area()
*/
fn area(&self) -> f64 {
self.x * self.y * self.radius
}
}
fn main() {
let c = Circle::new(1.0, 2.0, 3.0); // 堆区申请空间来存储对象数据
println!("{}", c.area());
}
➜ main make
rustc main.rs
./main
6
➜ main
2、接口与实现
1. 接口定义与实现
// 接口
trait HasArea {
fn area(&self) -> f64;
}
// 具体类
struct Rect {
width: f64,
height: f64,
}
// 让【具体类】实现【接口】
impl HasArea for Rect {
fn area(&self) -> f64 {
(self.width * self.height) // 作为返回值 => 必须使用 () 括起来，并不能写 ;
}
}
fn main()
{
let r = Rect {width:10.5, height:20.5};
println!("area = {:?}", r.area());
}
➜ main make
rustc main.rs
./main
area = 215.25
➜ main
2. 函数参数针对接口类型
1. fn run< T: HasArea>(r : &T);
// 接口
trait HasArea {
fn area(&self) -> f64;
}
// 具体类
struct Rect {
width: f64,
height: f64,
}
// 让【具体类】实现【接口】
impl HasArea for Rect {
fn area(&self) -> f64 {
(self.width * self.height) // 作为返回值 => 必须使用 () 括起来，并不能写 ;
}
}
// 全局函数 => 参数类型为接口类型
fn run<T: HasArea>(r : &T) {
println!("area = {:?}", r.area());
}
fn main()
{
let r = Rect {width:10.5, height:20.5};
run(&r);
}
➜ main make
rustc main.rs
./main
area = 215.25
➜ main
2. fn < T>(r : &T) where T: HasArea;
// 接口
trait HasArea {
fn area(&self) -> f64;
}
// 具体类
struct Rect {
width: f64,
height: f64,
}
// 让【具体类】实现【接口】
impl HasArea for Rect {
fn area(&self) -> f64 {
(self.width * self.height) // 作为返回值 => 必须使用 () 括起来，并不能写 ;
}
}
// 全局函数 => 参数类型为接口类型
// fn run<T: HasArea>(r : &T) {
// println!("area = {:?}", r.area());
// }
fn run<T>(r : &T) where T: HasArea
{
println!("area = {:?}", r.area());
}
fn main()
{
let r = Rect {width:10.5, height:20.5};
run(&r);
}
➜ main make
rustc main.rs
./main
area = 215.25
➜ main
3. where 使用
// 接口1
trait Man {
fn name(&self) -> String;
}
// 接口2
trait Animal {
fn name(&self) -> String;
}
// 接口3
trait Runnable {
fn run(&self);
}
fn make_pair<T, U>(a: T, b: U) -> (T, U)
where T: Man,
U: Animal + Runnable // 模板参数U必须实现两个接口
{
(a, b)
}
fn main()
{}
4. 使用系统接口
use std::fmt::Debug;
fn foo<T: Clone, K: Clone + Debug>(x: T, y: K) {
x.clone();
y.clone();
println!("{:?}", y);
}
fn bar<T, K>(x: T, y: K)
where T: Clone,
K: Clone + Debug
{
x.clone();
y.clone();
println!("{:?}", y);
}
3. 接口中可以带有方法默认实现
trait Foo {
fn foo(&self);
// default method
fn bar(&self) { println!("We called bar."); }
}
struct Baz;
impl Foo for Baz {
fn foo(&self) { println!("foo"); }
}
fn main()
{
let b = Baz{};
b.bar();
}
➜ main make
rustc main.rs
./main
We called bar.
➜ main
4. 接口的继承
trait Foo {
fn foo(&self);
// default method
fn foobar(&self) { println!("Foo::foobar()"); }
}
// 接口继承
trait FooBar : Foo {
fn foobar(&self);
}
struct Baz;
impl Foo for Baz {
fn foo(&self) { println!("foo"); }
}
impl FooBar for Baz {
fn foobar(&self) { println!("FooBar::foobar()"); }
}
fn main()
{
let b = Baz{};
// 调用不同接口的实现
Foo::foobar(&b);
FooBar::foobar(&b);
}
➜ main make
rustc main.rs
./main
Foo::foobar()
FooBar::foobar()
➜ main
5、运算符重载
1. 重载 + 操作符
use std::ops::Add;
#[derive(Debug)]
struct Point {
x: i32,
y: i32,
}
// 给struct重载+运算符
impl Add for Point {
// 1. 确定模板参数的具体数据类型
type Output = Point;
// 2. +运算符重载函数实现
fn add(self, other: Point) -> Point {
Point { x: self.x + other.x, y: self.y + other.y }
}
}
fn main() {
let p1 = Point { x: 1, y: 0 };
let p2 = Point { x: 2, y: 3 };
let p3 = p1 + p2;
println!("{:?}", p3);
}
➜ main make
rustc main.rs
./main
Point { x: 3, y: 3 }
➜ main
其他运算符重载套路相似。
2. 实现 Deref<Target=T>接口，则 *T 返回 &T类型的值
use std::ops::Deref;
// 实体类
struct Animal<T> {
value: T, // 成员value
}
// 实现 Deref<Target=T>，*对象 => 返回自定义的值
impl<T> Deref for Animal<T> {
// 1. 使用【预定义】模板参数Target指定deref()的返回值类型
type Target = T;
// 2. 实现deref()
fn deref(&self) -> &T {
return &self.value // 返回转换成的结果值
}
}
fn main() {
let anim = Animal { value: "monkey" };
println!("{}", *anim == "monkey");
println!("{}", *anim);
}
➜ main make
rustc main.rs
./main
true
monkey
➜ main
3. 实现 Deref<Target=T>接口，&U 的值自动强制转换为 &T 类型
use std::rc::Rc;
fn foo(s: &str) {
// borrow a string for a second
}
fn main()
{
// String implements Deref<Target=str>
let owned = "Hello".to_string();
// Rc 实现了 Deref<Target=T> 接口
// => &Rc对象，返回 &T
let counted = Rc::new(owned);
// therefore, this works:
foo(&counted);
}
➜ main make
rustc main.rs
./main
➜ main
4. &U 的多重嵌套
struct Foo;
impl Foo {
fn foo(&self) { println!("Foo() ..."); }
}
fn main()
{
let f = Foo;
f.foo();
(&f).foo();
(&&f).foo();
(&&&&&&&&f).foo();
}
➜ main make
rustc main.rs
./main
Foo() ...
Foo() ...
Foo() ...
Foo() ...
➜ main
