MENU
  1. ホーム
  2. Rust
  3. Rustのトレイトオブジェクト(dyn)を使った動的ディスパッチの基礎と応用

Rustのトレイトオブジェクト(dyn)を使った動的ディスパッチの基礎と応用

Rust

Rustのプログラミングにおいて、トレイトは強力で柔軟な抽象化の手段を提供します。特に、トレイトオブジェクトを用いることで、動的ディスパッチが可能となり、多様なシナリオでの柔軟な設計を実現できます。本記事では、Rustのdynキーワードを使ったトレイトオブジェクトと、それを活用した動的ディスパッチの基本的な仕組みから応用例までを網羅的に解説します。トレイトオブジェクトの利点、制約、そして効果的な使い方を学びながら、Rustのさらなる可能性を探求しましょう。

目次

Rustにおけるトレイトと動的ディスパッチの概要

トレイトとは何か


Rustにおけるトレイトは、他の言語でのインターフェースや型クラスに類似した機能を持つ機構で、特定の動作を抽象化するための手段です。トレイトを用いることで、異なる型に共通の振る舞いを定義できます。たとえば、次のようにトレイトを定義します：

trait Greeter {
    fn greet(&self);
}

このトレイトを実装する型は、greetメソッドを持つことを保証されます。

静的ディスパッチと動的ディスパッチ


Rustでは、トレイトを利用する際に静的ディスパッチと動的ディスパッチのどちらかを選択できます。

  1. 静的ディスパッチ
    コンパイル時に呼び出すメソッドが確定する方式で、実行時のオーバーヘッドが少なく高速です。ただし、型の情報を厳密に扱うため、柔軟性が制限される場合があります。
   fn greet_user<T: Greeter>(user: T) {
       user.greet();
   }
  1. 動的ディスパッチ
    実行時に呼び出すメソッドが決定する方式です。柔軟性が増しますが、実行時コストが発生します。この場合、トレイトオブジェクトを利用します。
   fn greet_user(user: &dyn Greeter) {
       user.greet();
   }

動的ディスパッチの必要性


動的ディスパッチは、型が動的に決定されるシナリオや、複数の型をまとめて扱いたい場合に有用です。たとえば、異なる種類のオブジェクトを同じコレクションで管理するケースや、ランタイムで振る舞いが変化するプログラムで役立ちます。Rustでは、これをdynキーワードを使用して実現します。

次の章では、dynキーワードの詳細とトレイトオブジェクトの作成方法について解説します。

`dyn`キーワードの役割と仕組み

`dyn`キーワードとは


dynキーワードは、Rustでトレイトオブジェクトを作成する際に使用されます。トレイトオブジェクトは、実行時に型情報を隠し、動的ディスパッチを可能にする抽象化の手段です。これにより、異なる型を1つのインターフェースを通じて扱えるようになります。

fn greet_user(user: &dyn Greeter) {
    user.greet();
}

上記の例では、&dyn Greeterがトレイトオブジェクトを示しています。このトレイトオブジェクトにより、複数の型が実装するGreeterトレイトのメソッドを統一的に呼び出すことが可能です。

トレイトオブジェクトの内部動作


トレイトオブジェクトは、以下の2つのコンポーネントから成り立っています：

  1. データ部分
    実際のデータ（例えば、構造体のインスタンス）への参照を保持します。
  2. vtable（仮想関数テーブル）
    トレイトに定義されたメソッドのポインタを保持するテーブルで、実行時に適切なメソッドを呼び出します。
let user: &dyn Greeter = &Person {};

このコードでは、userがデータ（Person構造体への参照）と、そのトレイトGreeterのメソッド群を参照するvtableを持つトレイトオブジェクトとなります。

例: トレイトオブジェクトの作成


以下に、トレイトオブジェクトを利用したシンプルな例を示します。

trait Greeter {
    fn greet(&self);
}

struct EnglishGreeter;
struct JapaneseGreeter;

impl Greeter for EnglishGreeter {
    fn greet(&self) {
        println!("Hello!");
    }
}

impl Greeter for JapaneseGreeter {
    fn greet(&self) {
        println!("こんにちは！");
    }
}

fn greet_all(greeters: Vec<&dyn Greeter>) {
    for greeter in greeters {
        greeter.greet();
    }
}

fn main() {
    let english = EnglishGreeter;
    let japanese = JapaneseGreeter;

    let greeters: Vec<&dyn Greeter> = vec![&english, &japanese];
    greet_all(greeters);
}

実行結果：

Hello!
こんにちは！

`dyn`を使う際の注意点

  1. パフォーマンスコスト
    動的ディスパッチは静的ディスパッチに比べて遅くなる可能性があります。頻繁に呼び出す部分では注意が必要です。
  2. サイズ情報の欠如
    トレイトオブジェクトはサイズが不明なため、直接スタック上に置くことはできません。常に参照やスマートポインタ（Box, Rcなど）を使う必要があります。

次の章では、トレイトオブジェクトが活用される典型的なシナリオについて解説します。

トレイトオブジェクトの活用シナリオ

異なる型を共通のインターフェースで操作する


トレイトオブジェクトの代表的な利用シナリオは、異なる型を1つのインターフェースで扱う場合です。たとえば、異なるメッセージ形式（テキスト、画像、動画など）を処理するシステムで、共通のMessageトレイトを実装した型を同じコレクションにまとめて管理できます。

trait Message {
    fn display(&self);
}

struct TextMessage {
    content: String,
}

struct ImageMessage {
    url: String,
}

impl Message for TextMessage {
    fn display(&self) {
        println!("Text: {}", self.content);
    }
}

impl Message for ImageMessage {
    fn display(&self) {
        println!("Image URL: {}", self.url);
    }
}

fn show_messages(messages: Vec<&dyn Message>) {
    for message in messages {
        message.display();
    }
}

fn main() {
    let text = TextMessage {
        content: "Hello, world!".to_string(),
    };
    let image = ImageMessage {
        url: "http://example.com/image.png".to_string(),
    };

    let messages: Vec<&dyn Message> = vec![&text, &image];
    show_messages(messages);
}

この例では、TextMessageとImageMessageが共通のMessageトレイトを実装しており、それぞれ異なる型のメッセージを1つのコレクションで処理しています。

動的プラグインシステム


動的ディスパッチを用いることで、プラグインシステムを簡潔に実装できます。アプリケーションの機能を後から追加する場合、トレイトオブジェクトを利用して抽象的なインターフェースを提供し、各プラグインがそれを実装する構成を取ります。

trait Plugin {
    fn execute(&self);
}

struct Logger;
struct Notifier;

impl Plugin for Logger {
    fn execute(&self) {
        println!("Logging activity...");
    }
}

impl Plugin for Notifier {
    fn execute(&self) {
        println!("Sending notification...");
    }
}

fn run_plugins(plugins: Vec<&dyn Plugin>) {
    for plugin in plugins {
        plugin.execute();
    }
}

fn main() {
    let logger = Logger;
    let notifier = Notifier;

    let plugins: Vec<&dyn Plugin> = vec![&logger, &notifier];
    run_plugins(plugins);
}

ゲーム開発におけるエンティティシステム


ゲームの開発では、キャラクター、アイテム、敵などを1つのコレクションで管理する必要があります。これらが共通の動作を持つ場合、トレイトオブジェクトが役立ちます。

trait Entity {
    fn update(&self);
}

struct Player;
struct Enemy;

impl Entity for Player {
    fn update(&self) {
        println!("Player is moving");
    }
}

impl Entity for Enemy {
    fn update(&self) {
        println!("Enemy is attacking");
    }
}

fn update_entities(entities: Vec<&dyn Entity>) {
    for entity in entities {
        entity.update();
    }
}

fn main() {
    let player = Player;
    let enemy = Enemy;

    let entities: Vec<&dyn Entity> = vec![&player, &enemy];
    update_entities(entities);
}

まとめ


トレイトオブジェクトは、異なる型を共通のインターフェースで操作したり、動的な拡張性を必要とするアプリケーションで威力を発揮します。次章では、プラグインシステムを構築する実践的なコード例について詳しく説明します。

実装例: トレイトオブジェクトを用いたプラグインシステム

プラグインシステムの概要


プラグインシステムでは、アプリケーションの機能を拡張可能にするための構造を提供します。トレイトオブジェクトを活用することで、各プラグインが共通のトレイトを実装し、動的に追加や変更が可能になります。ここでは、プラグインがそれぞれの機能を実行するシンプルな例を紹介します。

設計とコード例


以下にプラグインシステムのサンプルコードを示します。この例では、異なるプラグインが共通のPluginトレイトを実装しています。

// プラグインの共通インターフェース
trait Plugin {
    fn name(&self) -> &str;
    fn execute(&self);
}

// ログ出力プラグイン
struct LoggerPlugin;

impl Plugin for LoggerPlugin {
    fn name(&self) -> &str {
        "Logger"
    }

    fn execute(&self) {
        println!("Logging some information...");
    }
}

// 通知プラグイン
struct NotifierPlugin;

impl Plugin for NotifierPlugin {
    fn name(&self) -> &str {
        "Notifier"
    }

    fn execute(&self) {
        println!("Sending a notification...");
    }
}

// プラグインシステム
struct PluginSystem {
    plugins: Vec<Box<dyn Plugin>>,
}

impl PluginSystem {
    fn new() -> Self {
        PluginSystem { plugins: Vec::new() }
    }

    fn register_plugin(&mut self, plugin: Box<dyn Plugin>) {
        println!("Registering plugin: {}", plugin.name());
        self.plugins.push(plugin);
    }

    fn run_plugins(&self) {
        for plugin in &self.plugins {
            println!("Executing plugin: {}", plugin.name());
            plugin.execute();
        }
    }
}

fn main() {
    let mut system = PluginSystem::new();

    // プラグインの登録
    system.register_plugin(Box::new(LoggerPlugin));
    system.register_plugin(Box::new(NotifierPlugin));

    // プラグインの実行
    system.run_plugins();
}

実行結果


このコードを実行すると、以下の出力が得られます：

Registering plugin: Logger
Registering plugin: Notifier
Executing plugin: Logger
Logging some information...
Executing plugin: Notifier
Sending a notification...

コード解説

  1. 共通トレイトの定義
    Pluginトレイトは、全てのプラグインが実装すべきインターフェースを定義しています。
  2. Box<dyn Plugin>の使用
    トレイトオブジェクトをヒープに格納し、サイズの異なる型を一様に扱えるようにしています。
  3. プラグインの登録と実行
    register_pluginメソッドでプラグインを登録し、run_pluginsメソッドで全てのプラグインを動的に実行します。

応用: プラグインの動的ロード


このシステムをさらに発展させると、外部ファイルやネットワーク経由でプラグインを動的にロードする仕組みを実装できます。Rustでは、dlopenライブラリやlibloadingクレートを活用することで、動的ライブラリからプラグインをロードできます。

まとめ


このように、トレイトオブジェクトを用いることで、柔軟で拡張性の高いプラグインシステムを構築できます。次章では、トレイトオブジェクトを扱う際のライフタイム管理について詳しく解説します。

トレイトオブジェクトとライフタイムの管理

ライフタイムとは何か


Rustでは、メモリ安全性を保証するために参照の有効期間（ライフタイム）を明示的または暗黙的に指定します。トレイトオブジェクトを扱う場合も、ライフタイムの管理が必要です。特に、動的ディスパッチでは、トレイトオブジェクトの参照が指す実際のデータのライフタイムを正しく追跡しなければなりません。

ライフタイムが関わるトレイトオブジェクトの例


次のコード例は、トレイトオブジェクトのライフタイム管理における基本的な構造を示しています。

trait Printer {
    fn print(&self);
}

struct TextPrinter<'a> {
    text: &'a str,
}

impl<'a> Printer for TextPrinter<'a> {
    fn print(&self) {
        println!("{}", self.text);
    }
}

fn display(printer: &dyn Printer) {
    printer.print();
}

fn main() {
    let message = String::from("Hello, Rust!");
    let printer = TextPrinter { text: &message };

    display(&printer); // 正常に動作
}

上記の例では、TextPrinter構造体はライフタイムパラメータ'aを持ち、textフィールドの参照を追跡しています。このライフタイムがトレイトオブジェクトを安全に利用する鍵となります。

ライフタイムとトレイトオブジェクトの制約


トレイトオブジェクトのライフタイムには以下のような制約があります：

  1. 参照の有効期間の明示
    トレイトオブジェクトを保持する参照のライフタイムは、データのライフタイムより短くする必要があります。
   fn display<'a>(printer: &'a dyn Printer) {
       printer.print();
   }
  1. ライフタイムの明示が不要な場合
    一部のケースでは、ライフタイムはコンパイラによって推論され、明示する必要がありません。
   fn display(printer: &dyn Printer) {
       printer.print();
   }

ライフタイムエラーの例と解決方法


以下は、ライフタイムに関する典型的なエラー例です：

fn main() {
    let printer: &dyn Printer;
    {
        let message = String::from("Temporary message");
        let temp_printer = TextPrinter { text: &message };
        printer = &temp_printer; // ライフタイムエラー
    }
    printer.print(); // ここでは`message`が既に破棄されている
}

エラー原因：printerがスコープ外になったmessageを参照しているため、コンパイラが安全性を保証できません。

解決方法：ライフタイムを明示するか、所有権を移す構造を設計します。

fn main() {
    let message = String::from("Persistent message");
    let printer = TextPrinter { text: &message };

    display(&printer); // 安全に動作
}

Boxを用いたライフタイムの回避


ライフタイム管理が複雑になる場合、Boxを用いてトレイトオブジェクトを所有することで、ライフタイムエラーを回避できます。

fn main() {
    let message = String::from("Hello, Rust with Box!");
    let printer: Box<dyn Printer> = Box::new(TextPrinter { text: &message });

    printer.print(); // Boxが所有しているためライフタイムエラーなし
}

まとめ


トレイトオブジェクトとライフタイム管理は密接に関連しています。Rustのライフタイムシステムを正しく理解することで、安全かつ柔軟なコードを記述できます。次章では、静的ディスパッチとの性能比較について解説します。

静的ディスパッチとの性能比較

静的ディスパッチとは


静的ディスパッチは、コンパイル時に呼び出す関数が決定される方式です。Rustでは、ジェネリックやトレイト境界（trait bound）を用いたコードが静的ディスパッチを使用します。この方式では、関数の実体がコンパイル時にインライン化され、実行時のオーバーヘッドがほとんどありません。

例：

fn greet_user<T: Greeter>(user: T) {
    user.greet();
}

動的ディスパッチとの違い


動的ディスパッチでは、実行時に呼び出す関数が決定されます。これはトレイトオブジェクト（dyn）を使用する場合に採用され、ランタイムコストとしてvtable（仮想関数テーブル）の間接呼び出しが発生します。

例：

fn greet_user(user: &dyn Greeter) {
    user.greet();
}

性能比較の実験


以下のコードで、静的ディスパッチと動的ディスパッチの性能を比較します。

use std::time::Instant;

trait Greeter {
    fn greet(&self);
}

struct EnglishGreeter;
struct JapaneseGreeter;

impl Greeter for EnglishGreeter {
    fn greet(&self) {
        println!("Hello!");
    }
}

impl Greeter for JapaneseGreeter {
    fn greet(&self) {
        println!("こんにちは！");
    }
}

// 静的ディスパッチ
fn static_dispatch<T: Greeter>(greeter: T) {
    greeter.greet();
}

// 動的ディスパッチ
fn dynamic_dispatch(greeter: &dyn Greeter) {
    greeter.greet();
}

fn main() {
    let english = EnglishGreeter;
    let japanese = JapaneseGreeter;

    // 静的ディスパッチのベンチマーク
    let start = Instant::now();
    for _ in 0..1_000_000 {
        static_dispatch(&english);
        static_dispatch(&japanese);
    }
    println!("Static dispatch: {:?}", start.elapsed());

    // 動的ディスパッチのベンチマーク
    let start = Instant::now();
    for _ in 0..1_000_000 {
        dynamic_dispatch(&english);
        dynamic_dispatch(&japanese);
    }
    println!("Dynamic dispatch: {:?}", start.elapsed());
}

実行結果（例）


以下のような結果が得られる場合があります（実行環境によって異なります）：

Static dispatch: 50ms
Dynamic dispatch: 150ms

分析

  1. 静的ディスパッチの利点
  • コンパイル時に関数が確定し、インライン化されるため高速。
  • 実行時の間接呼び出しがない。
  • 特に頻繁な呼び出しやパフォーマンスが重要な部分で有効。
  1. 動的ディスパッチの利点
  • 柔軟性が高く、異なる型を扱う場合に便利。
  • ランタイムで型を切り替えるシナリオに適している。
  1. オーバーヘッド
  • 動的ディスパッチでは、vtableの参照と間接呼び出しが追加されるため、静的ディスパッチに比べて遅くなる。

静的ディスパッチを使うべき場合

  • パフォーマンスが重要な部分（例えば、ループ内の呼び出し）。
  • 型が固定されている場合。

動的ディスパッチを使うべき場合

  • 型が異なる複数のオブジェクトを共通のインターフェースで操作する必要がある場合。
  • ランタイムの柔軟性が求められる場合。

まとめ


静的ディスパッチは性能面で有利ですが、動的ディスパッチは設計の柔軟性を提供します。プロジェクトの要件に応じて適切に選択することが重要です。次章では、動的ディスパッチの制約や注意点について詳しく解説します。

トレイトオブジェクトの制約と注意点

トレイトオブジェクトの制約


トレイトオブジェクトにはいくつかの制約があり、それらを理解して正しく使用することが重要です。

1. オブジェクト安全性


トレイトオブジェクトを作成するには、トレイトがオブジェクト安全である必要があります。以下の条件を満たすトレイトのみがトレイトオブジェクトとして使用できます：

  • 自己型（Self）を参照しないメソッドのみを持つこと
    例：fn method(&self) は許容されるが、fn method(self: Self) や fn method(&self) -> Self は許容されない。
  • ジェネリックメソッドを含まないこと
    例：fn method<T>(&self, arg: T) のようなメソッドは許容されません。
trait ObjectSafe {
    fn display(&self); // オブジェクト安全
}

// 次のトレイトはオブジェクト安全ではない
trait NotObjectSafe {
    fn create() -> Self; // `Self`を返すため安全でない
}

2. サイズが不定


トレイトオブジェクトは実体型のサイズを隠蔽するため、スタック上に直接置けません。常に参照またはBoxなどのヒープベースの型で扱う必要があります。

fn main() {
    let obj: dyn ObjectSafe; // コンパイルエラー: サイズが不明
    let obj: &dyn ObjectSafe; // OK: 参照として使用
}

3. メソッドの制限


トレイトオブジェクトでは、トレイトに定義されたメソッドしか呼び出せません。特定の型に特化したメソッドにはアクセスできないため、これが制限となる場合があります。

trait Example {
    fn common(&self);
    fn specific(&self) where Self: Sized;
}

fn use_example(obj: &dyn Example) {
    obj.common(); // OK
    // obj.specific(); // コンパイルエラー: サイズ制約が必要
}

トレイトオブジェクトの注意点

1. パフォーマンスへの影響


動的ディスパッチによる間接呼び出しは、静的ディスパッチに比べてオーバーヘッドがあります。パフォーマンスが重要な箇所では静的ディスパッチを検討すべきです。

2. 型情報の喪失


トレイトオブジェクトは実行時に型情報を保持しないため、元の型を識別できません。ダウンキャストが必要な場合には、Anyトレイトを使用します。

use std::any::Any;

trait Example: Any {
    fn describe(&self);
}

struct MyType;

impl Example for MyType {
    fn describe(&self) {
        println!("I am MyType");
    }
}

fn main() {
    let obj: Box<dyn Example> = Box::new(MyType);

    if let Some(my_type) = obj.downcast_ref::<MyType>() {
        my_type.describe();
    } else {
        println!("Unknown type");
    }
}

3. 所有権とライフタイム


トレイトオブジェクトは参照やスマートポインタを通じて管理されるため、ライフタイムと所有権のルールを遵守する必要があります。特に、ライフタイム制約が複雑になる場合は、BoxやArcを利用して問題を回避できます。

トレイトオブジェクトの誤用を避ける方法

  • オブジェクト安全性を確認する：dynを使用する際には、トレイトがオブジェクト安全であることをチェックします。
  • 必要以上に動的ディスパッチを使わない：パフォーマンスが重要な場合は静的ディスパッチを優先します。
  • 型情報が必要な場合はAnyやGenericを活用する：動的ディスパッチでは失われる型情報を補う手段を用意します。

まとめ


トレイトオブジェクトは柔軟で強力な設計を可能にしますが、制約と注意点を正しく理解することが重要です。次章では、応用例としてトレイトオブジェクトを使ったUIコンポーネント設計について解説します。

応用例: トレイトオブジェクトを使ったUIコンポーネント設計

UIコンポーネント設計とトレイトオブジェクト


UIアプリケーションでは、ボタンやラベル、チェックボックスなどの異なるコンポーネントを一貫した方法で管理する必要があります。トレイトオブジェクトを使用すると、これらの異なるコンポーネントを共通のインターフェースで扱えるようになり、柔軟性と拡張性を高めることができます。

UIコンポーネントの設計例


次のコード例では、UIComponentというトレイトを定義し、それをトレイトオブジェクトとして使用して、異なるUI要素を管理しています。

// UIコンポーネントの共通トレイト
trait UIComponent {
    fn render(&self);
    fn click(&self);
}

// ボタンコンポーネント
struct Button {
    label: String,
}

impl UIComponent for Button {
    fn render(&self) {
        println!("Rendering Button: {}", self.label);
    }

    fn click(&self) {
        println!("Button '{}' clicked!", self.label);
    }
}

// ラベルコンポーネント
struct Label {
    text: String,
}

impl UIComponent for Label {
    fn render(&self) {
        println!("Rendering Label: {}", self.text);
    }

    fn click(&self) {
        println!("Label '{}' clicked!", self.text);
    }
}

// UIコンテナ
struct UIContainer {
    components: Vec<Box<dyn UIComponent>>,
}

impl UIContainer {
    fn new() -> Self {
        UIContainer {
            components: Vec::new(),
        }
    }

    fn add_component(&mut self, component: Box<dyn UIComponent>) {
        self.components.push(component);
    }

    fn render_all(&self) {
        for component in &self.components {
            component.render();
        }
    }

    fn click_all(&self) {
        for component in &self.components {
            component.click();
        }
    }
}

fn main() {
    let mut ui = UIContainer::new();

    let button = Button {
        label: "Submit".to_string(),
    };
    let label = Label {
        text: "Welcome to the UI".to_string(),
    };

    ui.add_component(Box::new(button));
    ui.add_component(Box::new(label));

    ui.render_all();
    ui.click_all();
}

実行結果


このコードを実行すると、以下のような出力が得られます：

Rendering Button: Submit
Rendering Label: Welcome to the UI
Button 'Submit' clicked!
Label 'Welcome to the UI' clicked!

コード解説

  1. 共通トレイトの定義
    UIComponentトレイトは、全てのUIコンポーネントが実装すべきインターフェースを定義しています。renderメソッドで表示、clickメソッドでクリックイベントを処理します。
  2. 異なる型のコンポーネントを格納
    Box<dyn UIComponent>を使用することで、異なる型のコンポーネントを同じVecに格納しています。
  3. 動的なコンポーネントの操作
    UIContainerは、追加されたコンポーネント全てを一括で操作します。これにより、管理が簡潔になります。

トレイトオブジェクトの利点と制約

  • 利点
  • 異なる型のコンポーネントを一貫して管理できる。
  • 新しいコンポーネントを追加する際のコード変更が最小限で済む。
  • 制約
  • 動的ディスパッチによるパフォーマンスのオーバーヘッド。
  • トレイトオブジェクトの制約により、一部の操作が限定される。

応用: UIのイベントハンドリング


さらに高度な設計では、クリックイベントを受け取り、対応する動作を動的に登録するシステムを構築できます。これは、トレイトオブジェクトとクロージャを組み合わせることで実現できます。

まとめ


トレイトオブジェクトを使用したUIコンポーネント設計は、柔軟で拡張性のあるアプリケーションを構築するのに適しています。次章では、これまで解説した内容をまとめ、トレイトオブジェクトの効果的な利用方法について再確認します。

まとめ


本記事では、Rustにおけるトレイトオブジェクト（dyn）を用いた動的ディスパッチについて、その基礎から応用例までを解説しました。動的ディスパッチは柔軟性を提供し、異なる型を一貫したインターフェースで扱えるため、プラグインシステムやUIコンポーネント設計など、さまざまな場面で役立ちます。

一方で、動的ディスパッチには性能面でのオーバーヘッドやトレイトオブジェクトの制約といったデメリットもあります。静的ディスパッチとのトレードオフを理解し、適切に選択することが重要です。この記事で学んだ知識を活用し、Rustプログラムの柔軟性と効率性をさらに高めましょう。

Rust
動的ディスパッチ Rust トレイトオブジェクト dyn

コメント

コメントする

目次