この記事では、Rust のDropトレイトとDerefトレイトについて説明していく。
それぞれdropメソッドとderefのメソッドを必須としているが、これらのメソッドを明示的に呼び出すことは稀で、多くの場合暗黙的に呼び出される。
トレイトそのものの初歩については以下を参照。
Drop トレイト
以下のコードでは、MyBoxというタプル構造体にDropトレイトを実装している。
Dropはuseを使ってインポートする必要はなく、そのまま使える。
そしてDropトレイトを実装している型はdropメソッドが必須であり、このメソッドはselfへのミュータブルな参照を引数として取る。
struct MyBox(String); impl Drop for MyBox { fn drop(&mut self) { println!("drop {}", self.0); } }
dropメソッドは、スコープを抜けたときに実行される。そのため以下のような結果になる。
struct MyBox(String); impl Drop for MyBox { fn drop(&mut self) { println!("drop {}", self.0); } } fn main() { let _x = MyBox(String::from("X")); { let _y = MyBox(String::from("Y")); } // drop Y } // drop X
この例ではprintln!を実行しているだけだが、Dropトレイトは主に、不要になったリソース（メモリなど）を解放するために使われる。
スコープを抜けたということはその値が使われることはもうないため、このタイミングでリソースを解放すると都合がよい。また、スコープを抜けたときに自動的に呼び出されるため、リソースを解放し忘れる恐れもない。
dropメソッドを手動で呼び出そうとすると、コンパイルエラーになる。
fn main() { let x = MyBox(String::from("X")); x.drop(); // explicit destructor calls not allowed }
std::mem::drop関数を使うことで、任意のタイミングでdropメソッドを呼び出すことができる。
この関数もDropトレイトと同様、useを使ってインポートする必要はない。
以下のコードを実行するとdrop X、endの順番で表示されるので、std::mem::drop関数を実行したタイミングでdropメソッドが呼び出されていることがわかる。
fn main() { let x = MyBox(String::from("X")); drop(x); println!("end") }
ドロップしたあとに値を使おうとするとコンパイルエラーになる。
fn main() { let x = MyBox(String::from("X")); drop(x); println!("{}", x.0); // value borrowed here after move }
ドロップする順番
複数の値が同時にスコープを抜けた場合、宣言された順番とは逆の順番でドロップしていく。
struct MyBox(String); impl Drop for MyBox { fn drop(&mut self) { println!("drop {}", self.0); } } fn main() { let _x = MyBox(String::from("X")); let _y = MyBox(String::from("Y")); let _z = MyBox(String::from("Z")); } // drop Z // drop Y // drop X
Dropトレイトを実装した型が入れ子になっている場合は、まず親がドロップされる。子については、宣言された順番にドロップされる。
struct Child(i32); struct Parent(Child, Child); impl Drop for Child { fn drop(&mut self) { println!("drop {}", self.0); } } impl Drop for Parent { fn drop(&mut self) { println!("drop Parent"); } } fn main() { let _x = Parent(Child(4), Child(5)); } // drop Parent // drop 4 // drop 5
Deref トレイト
*演算子を使うと、参照が指している値にアクセスすることができる。これを「参照外し」（dereference）という。
fn main() { let x = 1; let y = &x; println!("{}", x == *y); // true println!("{}", x == y); // can't compare `{integer}` with `&{integer}` }
構造体に対しては参照外しできない。
struct MyBox {} fn main() { let x = MyBox {}; let y = *x; // type `MyBox` cannot be dereferenced }
Derefトレイトを使うことで、構造体に対して参照外しができるようになる。
まずはシンプルな例を示す。
struct MyBox {} use std::ops::Deref; impl Deref for MyBox { type Target = i32; fn deref(&self) -> &Self::Target { &9 } } fn main() { let x = MyBox {}; let y = *x; println!("{}", y); // 9 println!("{}", y == 9); // true }
MyBoxのインスタンスであるxに対して参照外しをしたところ、9を得られた。
Deref トレイトの実装方法
DerefはDropと異なり、useでインポートする必要がある。
use std::ops::Deref;
Derefトレイトを実装する型にはtype Targetとderefメソッドが必須。
まずtype Targetだが、参照外しを行った際に得られる型を設定する。先程の例ではtype Target = i32;と書いたので、参照外しするとi32型の値が得られることになる。
そしてderefメソッドで、実際に得られる値の参照を返す。値ではなく参照を返すので、先程の例では9ではなく&9を返している。
構造体がジェネリックを使っている場合は以下のように書く。
struct MyBox<T> { value: T, } use std::ops::Deref; impl<T> Deref for MyBox<T> { type Target = T; fn deref(&self) -> &T { &self.value } } fn main() { let x = MyBox { value: 9 }; let y = MyBox { value: "abc" }; println!("{}", *x); // 9 println!("{}", *y); // abc }
なぜ Deref トレイトを実装すると参照外しできるようになるのか
xがDerefを実装してるとき、xに対して参照外しを行おうとすると、つまり*xと書くと、コンパイラはそれを*(x.deref())に変換する。Derefトレイトは必ずderefメソッドを持っているためそれが実行され、値を得られるのである。
xが以下のMyBoxのインスタンスであるとき、*xは*(x.deref())となり、derefメソッドが実行された結果*(&9)となり、それは最終的に9になる。
impl Deref for MyBox { type Target = i32; fn deref(&self) -> &Self::Target { &9 } }
fn main() { let x = MyBox {}; println!("{}", x.deref() == &9); // true println!("{}", *(&9) == 9); // true let y = *x; println!("{}", y == 9); // true }
参照外し型強制
Derefトレイトを実装している型の参照を関数に渡すと、「参照外し型強制」と呼ばれる処理が発生することがある。
以下のis_fooとis_i32はそれぞれ、Fooとi32の参照を引数として受け取る。そのためis_i32にFooの参照を渡せば、当然コンパイルエラーになる。
#[derive(Debug)] struct Foo {} fn is_foo(arg: &Foo) { println!("{:?}", arg); } fn is_i32(arg: &i32) { println!("{}", arg); } fn main() { is_i32(&7); // 7 let x = Foo {}; is_foo(&x); // Foo is_i32(&x); // expected `i32`, found struct `Foo` }
FooにDerefトレイトを実装してderefメソッドが&9を返すようにすると、is_i32にFooの参照を渡せるようになる。
コンパイラが暗黙的にderefを呼び出して&Fooを&9に変換しているため、このような結果になる。この挙動が、参照外し型強制である。
#[derive(Debug)] struct Foo {} use std::ops::Deref; impl Deref for Foo { type Target = i32; fn deref(&self) -> &Self::Target { println!("deref executed!"); &9 } } fn is_foo(arg: &Foo) { println!("{:?}", arg); } fn is_i32(arg: &i32) { println!("{}", arg); } fn main() { is_i32(&7); // 7 let x = Foo {}; is_foo(&x); // Foo is_i32(&x); // 9 }
上記を実行してみると、deref executed!は一度しか表示されないため、参照外し型強制は必要なときにしか発生しないことが分かる。
そのため、&Fooをis_fooに渡したときは参照外し型強制は発生せず、is_fooはそのまま&Fooを受け取る。
整理すると、参照外し型強制は以下の条件を全て満たしたときに発生する。
- 何らかの参照を関数に渡す
- 関数の引数の型が、渡された型と一致しない
- 渡された型が
Derefトレイトを実装している
参照外し型強制は、必要に応じて何度も繰り返される。
そのため以下のケースでは、&Fooをis_i32に渡した際に参照外し型強制が 2 回発生している。まず&Fooが&Barに変換され、さらに&Barが&9に変換される。
#[derive(Debug)] struct Foo {} #[derive(Debug)] struct Bar {} use std::ops::Deref; impl Deref for Foo { type Target = Bar; fn deref(&self) -> &Self::Target { println!("deref executed in Foo!"); &Bar {} } } impl Deref for Bar { type Target = i32; fn deref(&self) -> &Self::Target { println!("deref executed in Bar!"); &9 } } fn is_foo(arg: &Foo) { println!("{:?}", arg); } fn is_bar(arg: &Bar) { println!("{:?}", arg); } fn is_i32(arg: &i32) { println!("{}", arg); } fn main() { let x = Foo {}; // Foo is_foo(&x); // deref executed in Foo! // Bar is_bar(&x); // deref executed in Foo! // deref executed in Bar! // 9 is_i32(&x); }
String のケース
Stringも、Derefトレイトを実装している型のひとつ。
そのため以下のis_deref関数に渡すことができる。boolはDerefトレイトを実装していないため、渡すとコンパイルエラーになる。
struct Foo {} use std::ops::Deref; impl Deref for Foo { type Target = i32; fn deref(&self) -> &Self::Target { &9 } } fn is_deref<T: Deref>(_: T) { println!("is deref!"); } fn main() { is_deref(Foo {}); // is deref! is_deref(String::from("abc")); // is deref! is_deref(true); // expected an implementor of trait `std::ops::Deref` }
StringのDerefトレイトの実装はtype Target = strになっているため、derefメソッドは&strを返す。
そのため、&strを引数として受け取る関数helloに&Stringを渡すことができる。
fn hello(name: &str) { println!("Hello, {}!", name); } fn main() { let x = String::from("abc"); hello(&x); // Hello, abc! }
DerefMut
Derefトレイトに加えてDerefMutトレイトも実装すると、ミュータブルな参照も返せるようになる。
DerefMutトレイトを実装する型には、deref_mutメソッドが必須となる。
#[derive(Debug)] struct MyBox { value: i32, } use std::ops::Deref; use std::ops::DerefMut; impl Deref for MyBox { type Target = i32; fn deref(&self) -> &Self::Target { &self.value } } impl DerefMut for MyBox { fn deref_mut(&mut self) -> &mut Self::Target { &mut self.value } } fn main() { let mut x = MyBox { value: 9 }; *x = 8; println!("{:?}", x); // MyBox { value: 8 } println!("{}", *x == 8); // true }
状況に応じてderefとderef_mutのいずれかを呼び出す。
#[derive(Debug)] struct MyBox { value: i32, } use std::ops::Deref; use std::ops::DerefMut; impl Deref for MyBox { type Target = i32; fn deref(&self) -> &Self::Target { println!("deref"); &self.value } } impl DerefMut for MyBox { fn deref_mut(&mut self) -> &mut Self::Target { println!("deref_mut"); &mut self.value } } fn main() { let mut x = MyBox { value: 9 }; *x = 8; // deref_mut let _y = *x; // deref }
