MENU
  1. ホーム
  2. Rust
  3. Rust構造体・列挙型における型パラメーターの使用方法を徹底解説

Rust構造体・列挙型における型パラメーターの使用方法を徹底解説

Rust

Rustは、そのシンプルかつ強力な型システムによって、多様なプログラミングのニーズに応える言語です。その中でも、構造体や列挙型に型パラメーターを持たせる機能は、柔軟かつ再利用性の高いデータ構造を構築するうえで非常に重要です。型パラメーターを活用することで、異なる型のデータを扱う構造体や列挙型を1つの設計で統一的に扱うことができます。本記事では、Rustにおける型パラメーターの基本概念から、構造体や列挙型での実装方法、さらに応用的な使用例やトラブルシューティングまで、詳細に解説していきます。Rustの型システムを理解し、効率的なプログラミングを実現するための手助けとなる記事です。

目次

型パラメーターの基本概念


型パラメーターとは、Rustにおいてジェネリックプログラミングを可能にする仕組みの一つで、データ型を具体的に指定せずにコードを記述するためのものです。これにより、特定の型に依存しない汎用的な構造や関数を作成できます。

型パラメーターの仕組み


Rustでは、型パラメーターは<T>のように角括弧内に記述します。たとえば、struct Point<T>は、型パラメーターTを持つ構造体Pointを定義しています。この場合、Pointは任意の型でインスタンス化できます。

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let int_point = Point { x: 5, y: 10 };
    let float_point = Point { x: 1.0, y: 4.5 };
}

型パラメーターのメリット


型パラメーターを使用することで、以下のような利点が得られます。

1. 再利用性の向上


コードを複数の型で使用できるため、同じ機能を別々の型に対して繰り返し実装する必要がなくなります。

2. 型の安全性


Rustの型システムが、コンパイル時に型エラーを検出するため、予期せぬ動作を防止できます。

3. パフォーマンスの最適化


ジェネリック型はコンパイル時に具体的な型に置き換えられるため、ランタイムでのオーバーヘッドが発生しません（モノモーフィック化と呼ばれる仕組み）。

注意点


型パラメーターを使用する際には、必要に応じてトレイトバウンドを追加し、型に特定の振る舞い（メソッドや操作）を要求することが推奨されます。これにより、コンパイラが型の制約をより厳密にチェックできます。

struct Point<T: std::fmt::Display> {
    x: T,
    y: T,
}

fn print_point<T: std::fmt::Display>(point: Point<T>) {
    println!("Point({}, {})", point.x, point.y);
}

型パラメーターは、Rustプログラミングにおいて汎用性と安全性を両立させる強力なツールです。次章では、これを具体的に構造体で活用する方法を詳しく解説します。

構造体での型パラメーターの活用方法

Rustの構造体に型パラメーターを持たせることで、汎用的で再利用性の高いデータ構造を作成することができます。以下では、型パラメーターを使用した構造体の作成方法を具体例を交えながら解説します。

基本的な構造体の型パラメーター


型パラメーターを使用した構造体の定義は簡単です。構造体名の後に<T>を指定し、フィールドの型としてTを使用します。

struct Point<T> {
    x: T,
    y: T,
}

fn main() {
    let int_point = Point { x: 1, y: 2 };  // 整数型のPoint
    let float_point = Point { x: 1.5, y: 2.5 };  // 浮動小数点型のPoint
    println!("int_point: ({}, {})", int_point.x, int_point.y);
    println!("float_point: ({}, {})", float_point.x, float_point.y);
}

この例では、型パラメーターTを用いて、xとyが任意の型を取れる構造体Pointを定義しています。

複数の型パラメーターを持つ構造体


型パラメーターは複数持つことも可能です。これにより、異なる型をフィールドに持つ構造体を定義できます。

struct Pair<T, U> {
    first: T,
    second: U,
}

fn main() {
    let pair = Pair {
        first: "Hello",
        second: 42,
    };
    println!("Pair: ({}: {})", pair.first, pair.second);
}

この例では、型パラメーターTとUを使用して、firstとsecondに異なる型を持たせています。

型制約のある構造体


特定のトレイトを実装している型だけを許可したい場合、トレイトバウンドを追加できます。

use std::fmt::Display;

struct PrintablePoint<T: Display> {
    x: T,
    y: T,
}

fn print_point<T: Display>(point: PrintablePoint<T>) {
    println!("Point({}, {})", point.x, point.y);
}

fn main() {
    let point = PrintablePoint { x: 1, y: 2 };
    print_point(point);
}

この例では、型TがDisplayトレイトを実装している必要があります。そのため、xとyは表示可能な型でなければなりません。

デフォルト型を持つ構造体


型パラメーターにデフォルト値を設定することで、指定されなかった場合の型を明示できます（#![feature(generic_const_exprs)]を有効化する必要がある場合があります）。

struct Container<T = i32> {
    value: T,
}

fn main() {
    let default_container = Container { value: 10 };  // デフォルト型i32
    let string_container = Container { value: "Rust" };  // 明示的な型
    println!("Default: {}", default_container.value);
    println!("Custom: {}", string_container.value);
}

型パラメーターを構造体で活用することで、柔軟なデータ構造を作成し、Rustプログラミングの効率を大幅に向上させることが可能です。次章では、列挙型での型パラメーターの活用方法を解説します。

列挙型での型パラメーターの活用方法

Rustの列挙型に型パラメーターを持たせることで、異なる型を扱える柔軟なデータ構造を定義できます。型パラメーターを使用すると、1つの列挙型で複数のデータ型を統一的に扱うことが可能です。以下では、その基本的な使用方法と応用例を解説します。

型パラメーターを持つ列挙型の定義


列挙型に型パラメーターを追加する方法は構造体と同様です。型パラメーターは列挙型全体に適用されます。

enum Option<T> {
    Some(T),
    None,
}

fn main() {
    let some_value = Option::Some(42);
    let none_value: Option<i32> = Option::None;

    match some_value {
        Option::Some(value) => println!("Some: {}", value),
        Option::None => println!("None"),
    }
}

この例では、Option<T>という型パラメーターを持つ列挙型を定義しています。この列挙型は、任意の型Tを持つデータを保持できるSomeバリアントと、値を持たないNoneバリアントを持っています。

複数の型パラメーターを持つ列挙型


列挙型も構造体と同様に複数の型パラメーターを持つことができます。

enum Result<T, E> {
    Ok(T),
    Err(E),
}

fn main() {
    let success: Result<i32, &str> = Result::Ok(200);
    let failure: Result<i32, &str> = Result::Err("Error occurred");

    match success {
        Result::Ok(value) => println!("Success: {}", value),
        Result::Err(err) => println!("Failure: {}", err),
    }
}

この例では、Result<T, E>は2つの型パラメーターTとEを持つ列挙型です。Okバリアントには成功した値を、Errバリアントにはエラー情報を保持することができます。

型制約を持つ列挙型


列挙型の型パラメーターにもトレイトバウンドを適用できます。

use std::fmt::Display;

enum PrintableResult<T: Display> {
    Ok(T),
    Err(String),
}

fn print_result<T: Display>(result: PrintableResult<T>) {
    match result {
        PrintableResult::Ok(value) => println!("Ok: {}", value),
        PrintableResult::Err(err) => println!("Error: {}", err),
    }
}

fn main() {
    let result = PrintableResult::Ok(100);
    print_result(result);
}

この例では、型パラメーターTにDisplayトレイトを要求しています。そのため、Okバリアントの値は必ず表示可能な型でなければなりません。

応用例：ジェネリック列挙型を使った操作


型パラメーターを利用した列挙型は、パターンマッチングを使うことで柔軟に操作できます。

enum Command<T> {
    Add(T),
    Remove(T),
    Clear,
}

fn execute_command<T: std::fmt::Debug>(command: Command<T>) {
    match command {
        Command::Add(value) => println!("Adding: {:?}", value),
        Command::Remove(value) => println!("Removing: {:?}", value),
        Command::Clear => println!("Clearing all"),
    }
}

fn main() {
    let cmd1 = Command::Add(42);
    let cmd2 = Command::Remove("Item");
    let cmd3 = Command::Clear;

    execute_command(cmd1);
    execute_command(cmd2);
    execute_command(cmd3);
}

この例では、Command<T>という型パラメーターを持つ列挙型を使用しています。これにより、異なる型の操作コマンドを統一的に処理できます。

Rustの列挙型に型パラメーターを持たせることで、柔軟なデータ構造を作成し、複雑なロジックを簡潔に表現できます。次章では、型パラメーターにトレイトバウンドや制約を適用する方法を詳しく解説します。

型制約とトレイトバウンドの設定方法

Rustでは、型パラメーターに制約を設けることで、特定の振る舞いを持つ型だけを許可することができます。これを実現するのがトレイトバウンドです。トレイトバウンドを使用することで、コンパイラに型の制約を伝え、安全で予測可能なコードを記述できます。

トレイトバウンドの基本


型パラメーターTに特定のトレイトを実装する型のみを許可するには、T: トレイトの形式で制約を指定します。

use std::fmt::Display;

struct Point<T: Display> {
    x: T,
    y: T,
}

fn print_point<T: Display>(point: Point<T>) {
    println!("Point({}, {})", point.x, point.y);
}

fn main() {
    let point = Point { x: 5, y: 10 };
    print_point(point);
}

この例では、型パラメーターTにDisplayトレイトを実装している型のみを許可しています。そのため、xとyは必ず表示可能な型でなければなりません。

複数のトレイトバウンド


型パラメーターに複数の制約を適用するには、+を使います。

use std::fmt::{Debug, Display};

struct Pair<T: Debug + Display> {
    first: T,
    second: T,
}

fn print_pair<T: Debug + Display>(pair: Pair<T>) {
    println!("Pair: ({:?}, {})", pair.first, pair.second);
}

fn main() {
    let pair = Pair { first: 42, second: 100 };
    print_pair(pair);
}

この例では、型パラメーターTにDebugとDisplayの両方のトレイトを実装する型だけを許可しています。

where句を使ったトレイトバウンドの記述


トレイトバウンドが複雑になる場合、where句を使って簡潔に記述することができます。

use std::fmt::Display;

struct Container<T> {
    value: T,
}

fn display_container<T>(container: Container<T>)
where
    T: Display,
{
    println!("Container holds: {}", container.value);
}

fn main() {
    let container = Container { value: "Rust" };
    display_container(container);
}

この例では、関数の定義にwhere句を使用してトレイトバウンドを指定しています。これにより、コードが読みやすくなります。

トレイトバウンドとデフォルト型の組み合わせ


トレイトバウンドは、型パラメーターにデフォルト型を設定した場合にも使用できます。

use std::fmt::Display;

struct DefaultContainer<T: Display = i32> {
    value: T,
}

fn main() {
    let default_container = DefaultContainer { value: 100 };  // デフォルト型i32
    let custom_container = DefaultContainer { value: "Hello" };  // 明示的な型
    println!("Default: {}", default_container.value);
    println!("Custom: {}", custom_container.value);
}

ここでは、TにDisplayトレイトを実装した型である必要があることに加え、デフォルトでi32型が使用されるようにしています。

トレイトバウンドの実践例


以下は、トレイトバウンドを利用してジェネリック型を活用する実践例です。

use std::ops::Add;

struct Calculator<T: Add<Output = T>> {
    value1: T,
    value2: T,
}

impl<T: Add<Output = T>> Calculator<T> {
    fn calculate(&self) -> T {
        self.value1 + self.value2
    }
}

fn main() {
    let calc = Calculator { value1: 10, value2: 20 };
    println!("Sum: {}", calc.calculate());
}

この例では、Tが加算可能な型であることをAddトレイトで指定しています。これにより、Calculator構造体が安全に加算処理を行えるようになります。

トレイトバウンドを正しく活用することで、Rustプログラミングの安全性と汎用性をさらに高めることができます。次章では、型パラメーターを利用した実用的なデータ構造の設計方法を紹介します。

実用例：ジェネリックなデータ構造の作成

型パラメーターを活用すると、柔軟で再利用性の高いデータ構造を作成できます。この章では、型パラメーターを使った具体的なデータ構造の設計方法を解説します。Rustの強力な型システムを利用して、実用的な構造体や列挙型を作成してみましょう。

基本例：ジェネリックなスタック


スタック（LIFO構造）は多くのプログラムで利用されるデータ構造です。Rustの型パラメーターを活用して、どの型にも対応できるスタックを実装します。

struct Stack<T> {
    elements: Vec<T>,
}

impl<T> Stack<T> {
    fn new() -> Self {
        Stack { elements: Vec::new() }
    }

    fn push(&mut self, item: T) {
        self.elements.push(item);
    }

    fn pop(&mut self) -> Option<T> {
        self.elements.pop()
    }

    fn is_empty(&self) -> bool {
        self.elements.is_empty()
    }
}

fn main() {
    let mut stack = Stack::new();
    stack.push(1);
    stack.push(2);
    stack.push(3);

    while !stack.is_empty() {
        println!("Popped: {:?}", stack.pop());
    }
}

この例では、型パラメーターTを使用して、任意の型の要素を持つスタックを作成しました。このような汎用的な設計により、どのデータ型でも同じ構造を使い回すことができます。

応用例：ジェネリックなキーバリューストア


型パラメーターを2つ使用して、キーと値の型を指定できるキーバリューストアを作成します。

use std::collections::HashMap;

struct KeyValueStore<K, V> {
    store: HashMap<K, V>,
}

impl<K: std::cmp::Eq + std::hash::Hash, V> KeyValueStore<K, V> {
    fn new() -> Self {
        KeyValueStore { store: HashMap::new() }
    }

    fn insert(&mut self, key: K, value: V) {
        self.store.insert(key, value);
    }

    fn get(&self, key: &K) -> Option<&V> {
        self.store.get(key)
    }

    fn remove(&mut self, key: &K) -> Option<V> {
        self.store.remove(key)
    }
}

fn main() {
    let mut kv_store = KeyValueStore::new();
    kv_store.insert("name", "Rust");
    kv_store.insert("type", "Programming Language");

    if let Some(value) = kv_store.get(&"name") {
        println!("Key 'name': {}", value);
    }

    kv_store.remove(&"type");
}

この例では、型パラメーターKとVを使用して、キーと値の型を指定可能な汎用的なキーバリューストアを作成しました。

高度な例：型制約付きジェネリックデータ構造


型制約を導入することで、特定の振る舞いを持つ型だけを許可するデータ構造を作成できます。以下は加算可能な型を扱うカウンターの例です。

use std::ops::Add;

struct Counter<T>
where
    T: Add<Output = T> + Copy,
{
    count: T,
}

impl<T> Counter<T>
where
    T: Add<Output = T> + Copy,
{
    fn new(start: T) -> Self {
        Counter { count: start }
    }

    fn increment(&mut self, value: T) {
        self.count = self.count + value;
    }

    fn get(&self) -> T {
        self.count
    }
}

fn main() {
    let mut counter = Counter::new(0);
    counter.increment(5);
    counter.increment(10);
    println!("Current count: {}", counter.get());
}

この例では、型Tが加算可能（Addトレイトを実装）かつコピー可能であることを制約として指定しました。

型パラメーターを活用する利点

  1. コードの再利用性：異なる型のデータ構造を統一的に扱えるため、コードの重複を減らせます。
  2. 安全性：型システムが不正な型操作を防ぎ、バグを未然に防ぎます。
  3. パフォーマンス：コンパイル時に具体的な型に置き換えられるため、ランタイムオーバーヘッドがありません。

これらの例を通して、型パラメーターを活用した柔軟で実用的なデータ構造を設計する方法を理解いただけたかと思います。次章では、構造体や列挙型とジェネリック型を組み合わせた応用例を解説します。

構造体・列挙型とジェネリック型を組み合わせる応用例

構造体や列挙型にジェネリック型を組み合わせることで、さらに柔軟で汎用的なデータ構造を設計できます。ここでは、複数のジェネリック型を使用する実用的な例や、構造体と列挙型を組み合わせる方法を解説します。

応用例1: 構造体とジェネリック型の組み合わせ


複数のジェネリック型を使った柔軟なデータ構造を設計します。以下は、2つの型を持つペアとそれを格納するコンテナの例です。

struct Pair<T, U> {
    first: T,
    second: U,
}

struct Container<T, U> {
    items: Vec<Pair<T, U>>,
}

impl<T, U> Container<T, U> {
    fn new() -> Self {
        Container { items: Vec::new() }
    }

    fn add_pair(&mut self, first: T, second: U) {
        self.items.push(Pair { first, second });
    }

    fn get_pairs(&self) -> &Vec<Pair<T, U>> {
        &self.items
    }
}

fn main() {
    let mut container = Container::new();
    container.add_pair("Alice", 30);
    container.add_pair("Bob", 25);

    for pair in container.get_pairs() {
        println!("Name: {}, Age: {}", pair.first, pair.second);
    }
}

この例では、Containerに複数のPairを格納し、任意の型の組み合わせをサポートしています。

応用例2: 列挙型とジェネリック型の組み合わせ


列挙型にジェネリック型を持たせることで、異なる型の値を柔軟に扱えます。以下は、ジェネリック型を持つOperation列挙型の例です。

enum Operation<T, U> {
    Add(T, T),
    Subtract(T, T),
    Multiply(T, T),
    Concatenate(U, U),
}

fn execute_operation<T: std::ops::Add<Output = T> + std::ops::Sub<Output = T> + std::ops::Mul<Output = T>, U: std::string::ToString>(
    operation: Operation<T, U>,
) {
    match operation {
        Operation::Add(a, b) => println!("Add: {}", a + b),
        Operation::Subtract(a, b) => println!("Subtract: {}", a - b),
        Operation::Multiply(a, b) => println!("Multiply: {}", a * b),
        Operation::Concatenate(a, b) => println!("Concatenate: {}{}", a.to_string(), b.to_string()),
    }
}

fn main() {
    let add_op = Operation::Add(10, 20);
    let concat_op = Operation::Concatenate("Hello", "World");

    execute_operation(add_op);
    execute_operation(concat_op);
}

この例では、Operation列挙型を使用して数値の操作や文字列の連結を行っています。型パラメーターTとUのトレイトバウンドを適切に設定することで、異なる操作をサポートしています。

応用例3: 構造体と列挙型の組み合わせ


構造体のフィールドに列挙型を持たせ、さらにジェネリック型を適用します。以下は、タスク管理システムを表現する例です。

enum TaskStatus {
    Pending,
    InProgress,
    Completed,
}

struct Task<T> {
    id: T,
    name: String,
    status: TaskStatus,
}

struct TaskManager<T> {
    tasks: Vec<Task<T>>,
}

impl<T> TaskManager<T> {
    fn new() -> Self {
        TaskManager { tasks: Vec::new() }
    }

    fn add_task(&mut self, id: T, name: String, status: TaskStatus) {
        self.tasks.push(Task { id, name, status });
    }

    fn list_tasks(&self) {
        for task in &self.tasks {
            println!(
                "Task ID: {:?}, Name: {}, Status: {:?}",
                task.id, task.name, task.status
            );
        }
    }
}

fn main() {
    let mut manager = TaskManager::new();
    manager.add_task(1, "Learn Rust".to_string(), TaskStatus::InProgress);
    manager.add_task(2, "Build a project".to_string(), TaskStatus::Pending);

    manager.list_tasks();
}

この例では、TaskManagerにタスクの情報を管理させ、ジェネリック型Tを使用してタスクIDの型を柔軟にしています。

型パラメーターの組み合わせによる利点

  1. 柔軟性：異なる型を一つのデータ構造で管理可能。
  2. 再利用性：構造体や列挙型の汎用的な設計により、複数のシナリオで利用可能。
  3. 安全性：型チェックにより、コンパイル時に不正な操作を防止。

これらの応用例を参考に、複雑なデータ構造や操作をシンプルに設計できる方法を学んでください。次章では、型パラメーター関連のコンパイルエラーとその解決方法について解説します。

コンパイルエラーの対処方法

型パラメーターを使用する際、Rustのコンパイラは厳密な型チェックを行います。そのため、設計や記述にミスがあるとコンパイルエラーが発生することがあります。この章では、型パラメーターに関連するよくあるエラーの種類と、その解決方法を解説します。

エラー例1: 型パラメーターに必要なトレイトを実装していない


型パラメーターを使用したコードでは、特定の操作がトレイトに依存している場合、トレイトバウンドを忘れるとエラーになります。

エラーコード

struct Container<T> {
    value: T,
}

fn display_value<T>(container: Container<T>) {
    println!("{}", container.value);
}

エラー出力

error[E0277]: `T` doesn't implement `std::fmt::Display`

解決方法
トレイトバウンドを追加して、型TがDisplayトレイトを実装していることを明示します。

use std::fmt::Display;

struct Container<T> {
    value: T,
}

fn display_value<T: Display>(container: Container<T>) {
    println!("{}", container.value);
}

エラー例2: トレイトバウンドの不足による操作不能


型パラメーターに特定の操作を要求する場合、トレイトバウンドが不足しているとエラーになります。

エラーコード

fn sum<T>(a: T, b: T) -> T {
    a + b
}

エラー出力

error[E0369]: cannot add `T` to `T`

解決方法
Tに加算可能なトレイトAddをバウンドとして指定します。

use std::ops::Add;

fn sum<T: Add<Output = T>>(a: T, b: T) -> T {
    a + b
}

エラー例3: ジェネリック型の不一致


異なる型パラメーターを比較する際、コンパイラは型の不一致をエラーとして報告します。

エラーコード

struct Pair<T> {
    first: T,
    second: T,
}

fn are_equal<T>(pair1: Pair<T>, pair2: Pair<T>) -> bool {
    pair1.first == pair2.first
}

エラー出力

error[E0369]: binary operation `==` cannot be applied to type `T`

解決方法
型Tが比較可能なPartialEqトレイトを実装している必要があります。

struct Pair<T> {
    first: T,
    second: T,
}

fn are_equal<T: PartialEq>(pair1: Pair<T>, pair2: Pair<T>) -> bool {
    pair1.first == pair2.first
}

エラー例4: 借用に関するライフタイムの指定ミス


型パラメーターと同様に、借用に関連するライフタイムの指定が不足しているとエラーになります。

エラーコード

struct Container<T> {
    value: &T,
}

エラー出力

error[E0106]: missing lifetime specifier

解決方法
ライフタイムパラメーターを明示的に指定します。

struct Container<'a, T> {
    value: &'a T,
}

エラー例5: トレイトが実装されていない型の使用


型パラメーターで特定のトレイトを要求している場合、それを満たさない型を使用するとエラーになります。

エラーコード

use std::fmt::Display;

struct PrintableContainer<T: Display> {
    value: T,
}

fn main() {
    let container = PrintableContainer { value: vec![1, 2, 3] };
}

エラー出力

error[E0277]: `Vec<{integer}>` doesn't implement `std::fmt::Display`

解決方法
型TがDisplayを実装していることを確認するか、代替の型を使用します。

use std::fmt::Display;

struct PrintableContainer<T: Display> {
    value: T,
}

fn main() {
    let container = PrintableContainer { value: 123 };
}

エラー例6: ジェネリック型の複雑な制約不足


複数のトレイトを組み合わせた場合、複雑な制約が不足しているとエラーになります。

エラーコード

fn combine<T: Clone + std::fmt::Debug>(a: T, b: T) -> (T, T) {
    println!("{:?}", a);
    (a.clone(), b)
}

エラー出力

error[E0599]: no method named `clone` found for type `T`

解決方法
複数のトレイトバウンドをwhere句で整理し、見やすく記述します。

fn combine<T>(a: T, b: T) -> (T, T)
where
    T: Clone + std::fmt::Debug,
{
    println!("{:?}", a);
    (a.clone(), b)
}

型パラメーターエラーの防止策

  1. トレイトバウンドを明確に記述: 型がどのトレイトに依存するかを必ず明示する。
  2. エラーメッセージを活用: コンパイラのエラーメッセージは解決のヒントを多く含む。
  3. 小さなステップで実装: 一度に多くのジェネリック型やトレイトバウンドを適用せず、段階的に進める。

次章では、型パラメーターを使った練習問題を通じて、理解をさらに深めます。

演習問題：型パラメーターを使った構造体・列挙型の実装

ここでは、これまで学んだ型パラメーターの知識を実際に使ってみるための演習問題を用意しました。問題を解きながら、Rustにおける型パラメーターの理解を深めてください。

問題1: ジェネリック型を使ったデータペアの作成

以下の要件を満たすPair<T, U>構造体を実装してください。

  1. firstとsecondの2つのフィールドを持つ。
  2. 任意の型TとUを受け取れる。
  3. display()メソッドを実装し、ペアの値を表示する。

例

let pair = Pair { first: 42, second: "Rust" };
pair.display(); // "Pair: 42 and Rust"

ヒント: 型TとUにDisplayトレイトを実装する制約を追加してください。

問題2: 型制約付きのスタックの実装

以下の要件を満たすジェネリック型のStack<T>を実装してください。

  1. 内部にVec<T>を使用して要素を格納する。
  2. push()、pop()、peek()の3つのメソッドを持つ。
  • push(item: T)は要素を追加する。
  • pop()は最後の要素を削除して返す（要素がない場合はNoneを返す）。
  • peek()は最後の要素を削除せずに返す（要素がない場合はNoneを返す）。
  1. 要素型Tがコピー可能（Copyトレイトを実装）であることを要求する。

例

let mut stack = Stack::new();
stack.push(1);
stack.push(2);
println!("{:?}", stack.peek()); // Some(2)
println!("{:?}", stack.pop()); // Some(2)

問題3: 列挙型を使ったエラーハンドリング

以下の要件を満たすResult<T, E>列挙型を実装してください。

  1. Ok(T)バリアントとErr(E)バリアントを持つ。
  2. 型Tは任意の型を受け取れる。
  3. 型EはエラーメッセージとしてString型を使用する。
  4. 列挙型に対してis_ok()とis_err()のメソッドを実装する。
  • is_ok()は結果が成功（Ok）の場合にtrueを返す。
  • is_err()は結果がエラー（Err）の場合にtrueを返す。

例

let result: Result<i32, String> = Result::Ok(42);
println!("{}", result.is_ok()); // true
println!("{}", result.is_err()); // false

let error: Result<i32, String> = Result::Err("An error occurred".to_string());
println!("{}", error.is_ok()); // false
println!("{}", error.is_err()); // true

問題4: ジェネリック型とトレイトバウンドを組み合わせた操作

以下の要件を満たすCalculator<T>構造体を実装してください。

  1. 内部フィールドに2つの値aとbを持つ。
  2. 型Tが加算（Add）、減算（Sub）、乗算（Mul）可能であることを要求する。
  3. add(), subtract(), multiply()の3つのメソッドを持つ。

例

let calc = Calculator { a: 10, b: 20 };
println!("{}", calc.add()); // 30
println!("{}", calc.subtract()); // -10
println!("{}", calc.multiply()); // 200

ヒント: std::ops::Addなどのトレイトを利用してください。

解答例

問題を解き終えたら、解答を以下の形で記述してください。

// 問題1の解答例
struct Pair<T, U> {
    first: T,
    second: U,
}

// その他の問題も同様に記述

演習問題を解くことで、型パラメーターの使用方法やトレイトバウンドの活用方法を実践的に理解できるようになります。次章では、本記事の内容をまとめます。

まとめ

本記事では、Rustにおける構造体や列挙型に型パラメーターを持たせる方法を解説しました。型パラメーターを使用することで、汎用的で再利用性の高いデータ構造を構築でき、プログラムの柔軟性と効率性を向上させることができます。

具体的には以下の内容を扱いました：

  • 型パラメーターの基本概念と利点
  • 構造体や列挙型での型パラメーターの使用例
  • トレイトバウンドによる型制約の方法
  • 実用的なデータ構造や応用例
  • コンパイルエラーの対処法
  • 演習問題を通じた実践的な理解

型パラメーターを適切に活用することで、安全性と効率性を兼ね備えたプログラムを設計するスキルが身につきます。Rustの強力な型システムをマスターし、プロジェクトに応用してください。

Rust
プログラミング Rust 型パラメーター

コメント

コメントする

目次