Rustは、安全性とパフォーマンスを兼ね備えたプログラミング言語として、多くの開発者に支持されています。特にその所有権システムにより、メモリの管理が効率的かつ安全に行われます。しかし、この所有権システムが原因で、構造体のフィールドを変更する場合に特有の制約が生じます。本記事では、Rustの構造体でフィールドを変更可能にする具体的な手法や、所有権と可変性に関連する制約について解説します。さらに、実用的な応用例や安全性を確保するための設計パターンについても詳しく紹介します。これを読めば、Rustの特徴を最大限に活用しながら効率的なプログラミングが可能になるでしょう。
Rustの構造体の基本構造
Rustの構造体（struct）は、関連するデータをまとめて管理するための便利なデータ型です。構造体を定義することで、コードの可読性と再利用性を向上させることができます。以下では、構造体の基本構造とその使用例を見ていきます。
構造体の定義
Rustでは、structキーワードを使用して構造体を定義します。フィールド名とその型を指定することで、独自のデータ型を作成できます。
struct User {
name: String,
age: u32,
email: String,
}この例では、Userという名前の構造体を定義し、name、age、emailの3つのフィールドを持たせています。
構造体のインスタンスの生成
構造体を使用するには、フィールドに値を設定してインスタンスを作成します。
let user = User {
name: String::from("Alice"),
age: 30,
email: String::from("alice@example.com"),
};インスタンスが作成されたら、.（ドット）を使用してフィールドにアクセスできます。
println!("User name: {}", user.name);
println!("User age: {}", user.age);構造体のデフォルト値と構造体更新記法
構造体には、デフォルト値や更新記法を使用して効率的にインスタンスを作成できます。
struct User {
name: String,
age: u32,
email: String,
}
let user1 = User {
name: String::from("Alice"),
age: 30,
email: String::from("alice@example.com"),
};
let user2 = User {
name: String::from("Bob"),
..user1 // 他のフィールドをuser1からコピー
};これにより、コードの重複を減らすことが可能です。
タプル構造体
Rustでは、名前付きフィールドを持たない「タプル構造体」も定義できます。
struct Color(u8, u8, u8);
let black = Color(0, 0, 0);
println!("Black color: {}, {}, {}", black.0, black.1, black.2);タプル構造体は、シンプルなデータを扱う場合に便利です。
ユニット構造体
フィールドを持たない「ユニット構造体」も存在します。これは、特定の値を持たないマーカーとして使われます。
struct Marker;
let marker = Marker;これらの基本概念を理解することで、Rustの構造体を効率的に利用できるようになります。次に、構造体のフィールドを変更可能にする方法を見ていきます。
mutキーワードを使ったフィールドの変更
Rustでは、デフォルトで構造体のインスタンスは不変（変更不可）です。しかし、特定のフィールドやインスタンス全体を変更可能にするには、mutキーワードを活用する必要があります。このセクションでは、mutを使用したフィールドの変更方法を解説します。
インスタンス全体を可変にする
構造体のフィールドを変更するには、まずインスタンスをmutキーワードで宣言する必要があります。
struct User {
name: String,
age: u32,
}
fn main() {
let mut user = User {
name: String::from("Alice"),
age: 30,
};
user.age = 31; // フィールドの変更
println!("Updated age: {}", user.age);
}このコードでは、userインスタンスがmutとして宣言されているため、ageフィールドの値を変更できます。
関数内での変更可能な構造体
関数に変更可能な構造体を渡す場合も、mutキーワードを使用します。
fn update_age(user: &mut User, new_age: u32) {
user.age = new_age;
}
fn main() {
let mut user = User {
name: String::from("Bob"),
age: 25,
};
update_age(&mut user, 26);
println!("Updated age: {}", user.age);
}この例では、update_age関数が構造体の可変参照を受け取り、ageフィールドを更新しています。
部分的に可変なフィールドの制御
一部のフィールドだけを変更可能にすることは直接的にはできませんが、所有権の分割やラップ型を活用することで似たような効果を得られます。たとえば、フィールドにCell型を使用することで、特定のフィールドを変更可能にできます（詳細は後述します）。
所有権とmutの制約
Rustの所有権システムにより、同時に複数の可変参照を持つことはできません。以下のコードはエラーになります。
fn main() {
let mut user = User {
name: String::from("Alice"),
age: 30,
};
let age_ref1 = &mut user.age; // 可変参照
let age_ref2 = &mut user.age; // 同時に別の可変参照を作成 → エラー
}これは、データ競合を防ぐためのRustの所有権モデルの一部です。
実用的な注意点
mutを使うとコードが柔軟になりますが、不必要な変更を防ぐために最小限に抑えるべきです。- インスタンスの可変性を明示することで、コードの安全性と可読性が向上します。
次に、可変参照を活用してフィールドを変更する方法についてさらに詳しく見ていきます。
フィールドに対する可変参照の付与
Rustでは、構造体のフィールドを効率的に操作するために、可変参照を使用することができます。このセクションでは、可変参照を使ってフィールドを変更する方法と、その制約について詳しく解説します。
可変参照の基礎
Rustの所有権システムでは、可変参照を使うことで構造体の一部のフィールドを変更可能にできます。以下は基本的な例です。
struct User {
name: String,
age: u32,
}
fn main() {
let mut user = User {
name: String::from("Alice"),
age: 30,
};
{
let age_ref = &mut user.age; // 可変参照を作成
*age_ref += 1; // 可変参照を使って値を変更
}
println!("Updated age: {}", user.age);
}このコードでは、&mutを使ってuser.ageへの可変参照を作成し、値をインクリメントしています。
可変参照のスコープと制約
Rustでは、可変参照が有効なスコープ内で他の参照を作成することはできません。これによりデータ競合が防がれます。
fn main() {
let mut user = User {
name: String::from("Bob"),
age: 25,
};
let age_ref = &mut user.age; // 可変参照を作成
// println!("{}", user.name); // 同時に不変参照を作成 → エラー
*age_ref += 1; // 変更を行う
}この例では、user.ageへの可変参照が有効な間、user.nameへの不変参照を作成しようとするとコンパイルエラーになります。
ネストした可変参照の制約
構造体全体への可変参照とその一部のフィールドへの可変参照を同時に持つことはできません。
fn main() {
let mut user = User {
name: String::from("Charlie"),
age: 28,
};
let user_ref = &mut user; // 全体への可変参照
// let age_ref = &mut user.age; // 部分フィールドへの可変参照 → エラー
user_ref.age += 1; // 全体の参照を通じて変更を行う
}Rustはこのような操作を禁止することで、データ競合の可能性を排除しています。
可変参照の効果的な活用
可変参照を使う際は、以下の点を考慮することでコードを効率的かつ安全に記述できます。
- スコープを短く保つ: 可変参照のスコープを可能な限り短くし、他の操作に干渉しないようにします。
- 部分的な変更を明示: 必要なフィールドにのみ可変参照を適用し、変更箇所を明確にします。
- データ競合の回避: 必要がない限り複数の参照を同時に持たないようにします。
応用例: フィールドの更新を伴う処理
以下の例では、可変参照を使ってフィールドを更新する関数を作成します。
fn update_name(user: &mut User, new_name: &str) {
user.name = String::from(new_name);
}
fn main() {
let mut user = User {
name: String::from("Alice"),
age: 30,
};
update_name(&mut user, "Alice Smith");
println!("Updated name: {}", user.name);
}このように可変参照を活用することで、構造体のフィールドを柔軟に変更することができます。
次に、変更可能なフィールドの安全性を確保するための手法を解説します。
変更可能な構造体フィールドの安全性の確保
Rustの所有権システムは、安全性を保証するために複数のルールを設けています。構造体のフィールドを変更する際も、安全性を保つためにこれらのルールを順守する必要があります。このセクションでは、変更可能なフィールドの安全性を確保するための手法について解説します。
所有権と可変性の基本
Rustでは、1つのデータに対して複数の可変参照を同時に作成することを禁止しています。このルールにより、データ競合が防止されます。以下のコードはエラーを示す例です。
struct User {
name: String,
age: u32,
}
fn main() {
let mut user = User {
name: String::from("Alice"),
age: 30,
};
let ref1 = &mut user.age;
let ref2 = &mut user.age; // 同時に別の可変参照を作成 → エラー
}この制約を順守することで、実行時にデータが不整合になることを防ぎます。
スコープを限定して安全性を向上
可変参照を使う場合、スコープを短く保つことが安全性の向上につながります。スコープが短ければ、他の参照との競合が発生しにくくなります。
fn main() {
let mut user = User {
name: String::from("Alice"),
age: 30,
};
{
let age_ref = &mut user.age;
*age_ref += 1; // スコープ内で変更
}
println!("Updated age: {}", user.age);
}スコープが終了すると、可変参照が無効化されるため、次の操作が安全に行えます。
Cell型を利用した内部可変性
Rustでは、Cell型を使うことで、所有権のルールに影響されずにフィールドを変更可能にする「内部可変性」という仕組みを利用できます。
use std::cell::Cell;
struct User {
name: String,
age: Cell<u32>,
}
fn main() {
let user = User {
name: String::from("Alice"),
age: Cell::new(30),
};
user.age.set(31); // Cellを使って値を変更
println!("Updated age: {}", user.age.get());
}Cellは単一スレッド環境で使用することを前提としており、所有権ルールに違反せずにフィールドの変更を行えます。
RefCell型による複雑な内部可変性
RefCellは、複数の可変参照を持ちたい場合や、動的にフィールドを変更する場合に役立ちます。
use std::cell::RefCell;
struct User {
name: String,
age: RefCell<u32>,
}
fn main() {
let user = User {
name: String::from("Alice"),
age: RefCell::new(30),
};
{
let mut age_ref = user.age.borrow_mut();
*age_ref += 1;
}
println!("Updated age: {}", user.age.borrow());
}RefCellは実行時に借用ルールをチェックし、違反があればパニックを発生させます。
スレッド安全性を考慮した変更
マルチスレッド環境でフィールドを変更する場合は、MutexやRwLockを使用することでスレッド間のデータ競合を防ぐことができます（詳細は後述）。
実践的なアドバイス
- 簡単な変更は
mutやCellを使い、複雑な場合はRefCellを検討しましょう。 - 可変参照のスコープを短く保つことで、競合の可能性を減らします。
- スレッド安全性が必要な場合は適切な同期プリミティブを使用しましょう。
次に、Cell型やRefCell型を活用した内部可変性の実装について詳しく見ていきます。
Cell型とRefCell型の活用
Rustでは、安全なコードを保証するため、基本的に所有権と借用ルールが厳格に適用されます。しかし、内部可変性を実現するために、所有権ルールの例外としてCell型やRefCell型が用意されています。このセクションでは、Cell型とRefCell型の基本的な使い方と実用的な応用例について解説します。
Cell型の概要
Cell型は、単一スレッド環境で値を内部的に変更するための型です。フィールドの値を安全に変更するためのAPIを提供し、コンパイル時の借用ルールを回避します。
Cell型の基本的な使い方
以下は、Cell型を用いてフィールドを変更可能にする例です。
use std::cell::Cell;
struct User {
name: String,
age: Cell<u32>,
}
fn main() {
let user = User {
name: String::from("Alice"),
age: Cell::new(30),
};
user.age.set(31); // Cellを使って値を変更
println!("Updated age: {}", user.age.get());
}このコードでは、Cell::newを使用してageをラップし、setとgetメソッドを使って値を変更・取得しています。
Cell型の制約
Cell型はコピー可能なデータ型（Copyトレイトを実装している型）のみ使用可能です。- 内部の値に対して直接的な参照を取得することはできません。
RefCell型の概要
RefCell型は、実行時に借用ルールをチェックすることで、より柔軟な内部可変性を提供します。これにより、実行時に複数の不変参照または1つの可変参照を持つことが可能になります。
RefCell型の基本的な使い方
以下の例では、RefCellを使ってフィールドの値を変更しています。
use std::cell::RefCell;
struct User {
name: String,
age: RefCell<u32>,
}
fn main() {
let user = User {
name: String::from("Alice"),
age: RefCell::new(30),
};
{
let mut age_ref = user.age.borrow_mut(); // 可変参照を借用
*age_ref += 1; // 値を変更
}
println!("Updated age: {}", user.age.borrow()); // 不変参照を借用
}borrow_mutは可変参照を取得し、borrowは不変参照を取得します。
RefCell型の制約
- 借用ルールが実行時にチェックされるため、誤用が発生した場合はパニックになります。
- 単一スレッド環境での使用に限られます。
Cell型とRefCell型の違い
| 特徴 | Cell型 | RefCell型 |
|---|---|---|
| 使用対象 | Copyトレイトを持つ型 | 任意の型 |
| 値へのアクセス方法 | 値をコピーして操作 | 借用して操作 |
| 借用ルールチェック | コンパイル時 | 実行時 |
実用例: 内部可変性を活用した構造体
以下の例では、Cell型とRefCell型を組み合わせた実用的な構造体を示します。
use std::cell::{Cell, RefCell};
struct Counter {
count: Cell<u32>,
history: RefCell<Vec<u32>>,
}
impl Counter {
fn increment(&self) {
let current = self.count.get();
self.count.set(current + 1);
self.history.borrow_mut().push(current + 1);
}
fn get_history(&self) -> Vec<u32> {
self.history.borrow().clone()
}
}
fn main() {
let counter = Counter {
count: Cell::new(0),
history: RefCell::new(vec![]),
};
counter.increment();
counter.increment();
println!("History: {:?}", counter.get_history());
}この例では、countにはCell型を使用してスレッドセーフに値を更新し、historyにはRefCell型を使用して履歴を記録しています。
まとめ
Cell型とRefCell型は、所有権ルールを遵守しながら内部可変性を実現するための強力なツールです。Cell型はコピー可能な型に適し、RefCell型は任意の型に対応します。- 適切な型を選択することで、安全かつ柔軟なコードを記述できます。
次に、実用例として可変フィールドを持つ設定構造体を詳しく見ていきます。
実用例：可変フィールドを持つ設定構造体
可変フィールドは、特にプログラムの設定や状態管理に役立ちます。このセクションでは、Cell型やRefCell型を活用した実用的な設定構造体の例を通して、柔軟な設計方法を解説します。
基本例：動的に更新可能な設定構造体
以下のコードは、Cell型を使って動的に更新可能な設定構造体を実装した例です。
use std::cell::Cell;
struct Config {
debug_mode: Cell<bool>,
max_connections: Cell<u32>,
}
impl Config {
fn enable_debug(&self) {
self.debug_mode.set(true);
}
fn disable_debug(&self) {
self.debug_mode.set(false);
}
fn set_max_connections(&self, max: u32) {
self.max_connections.set(max);
}
fn is_debug_enabled(&self) -> bool {
self.debug_mode.get()
}
fn get_max_connections(&self) -> u32 {
self.max_connections.get()
}
}
fn main() {
let config = Config {
debug_mode: Cell::new(false),
max_connections: Cell::new(100),
};
config.enable_debug();
println!("Debug mode: {}", config.is_debug_enabled());
config.set_max_connections(200);
println!("Max connections: {}", config.get_max_connections());
}この例では、Cell型を使うことで、Configインスタンスを&selfとして使用しながらも、フィールドを更新できるようにしています。
複雑な構造：RefCell型による動的リスト管理
次に、RefCell型を活用して、動的に更新可能なリストを含む設定構造体を作成します。
use std::cell::RefCell;
struct Config {
options: RefCell<Vec<String>>,
}
impl Config {
fn add_option(&self, option: &str) {
self.options.borrow_mut().push(option.to_string());
}
fn get_options(&self) -> Vec<String> {
self.options.borrow().clone()
}
}
fn main() {
let config = Config {
options: RefCell::new(vec![]),
};
config.add_option("Enable logging");
config.add_option("Use cache");
println!("Config options: {:?}", config.get_options());
}この例では、RefCell型を使ってoptionsフィールドに対する可変参照を安全に管理し、動的なリストの更新を可能にしています。
応用例：設定変更と履歴の追跡
以下は、設定の変更履歴を記録する構造体を実装した例です。
use std::cell::{Cell, RefCell};
struct Config {
current_mode: Cell<String>,
history: RefCell<Vec<String>>,
}
impl Config {
fn set_mode(&self, new_mode: &str) {
let old_mode = self.current_mode.replace(new_mode.to_string());
self.history.borrow_mut().push(old_mode);
}
fn get_history(&self) -> Vec<String> {
self.history.borrow().clone()
}
fn get_current_mode(&self) -> String {
self.current_mode.get().clone()
}
}
fn main() {
let config = Config {
current_mode: Cell::new("Normal".to_string()),
history: RefCell::new(vec![]),
};
config.set_mode("Debug");
config.set_mode("Safe");
println!("Current mode: {}", config.get_current_mode());
println!("Mode history: {:?}", config.get_history());
}この例では、Cell::replaceメソッドを使用して現在のモードを更新し、古いモードを履歴に記録しています。
設計上の注意点
Cell型は単純な値変更に適していますが、複雑な構造の変更にはRefCell型が適しています。- 可変フィールドを多用する場合は、変更箇所を最小限に抑えるよう設計してください。
- スレッドセーフ性が必要な場合は、
MutexやRwLockを使用してください（次節で解説）。
これらの例を参考にすることで、実際のプログラムに適した可変フィールドの設計が可能になります。次に、スレッド安全性を考慮したフィールド変更方法を解説します。
変更可能なフィールドとスレッド安全性の考慮
Rustのマルチスレッド環境でデータを扱う場合、スレッド間のデータ競合を防ぐために適切な同期が必要です。スレッドセーフ性を確保しながらフィールドを変更するには、Rustの同期プリミティブを活用します。このセクションでは、MutexやRwLockなどを利用したスレッドセーフな変更方法を解説します。
Mutexを使用したスレッドセーフな変更
Mutexは、ある時点で1つのスレッドのみがデータにアクセスできるようにする同期プリミティブです。以下は、Mutexを使用してスレッドセーフにフィールドを変更する例です。
use std::sync::Mutex;
use std::thread;
struct Config {
max_connections: Mutex<u32>,
}
fn main() {
let config = Config {
max_connections: Mutex::new(100),
};
let handles: Vec<_> = (0..10)
.map(|_| {
let config = &config;
thread::spawn(move || {
let mut max_connections = config.max_connections.lock().unwrap();
*max_connections += 1;
println!("Updated max_connections: {}", *max_connections);
})
})
.collect();
for handle in handles {
handle.join().unwrap();
}
}このコードでは、config.max_connectionsをMutexでラップし、lockメソッドを使って排他的にアクセスしています。
RwLockを使用した同時読み取りと排他的書き込み
RwLock（Read-Write Lock）は、複数のスレッドが同時にデータを読み取れるようにしつつ、書き込み時には排他的なロックを提供します。
use std::sync::RwLock;
use std::thread;
struct Config {
debug_mode: RwLock<bool>,
}
fn main() {
let config = Config {
debug_mode: RwLock::new(false),
};
let handles: Vec<_> = (0..5)
.map(|i| {
let config = &config;
thread::spawn(move || {
if i % 2 == 0 {
let mut debug_mode = config.debug_mode.write().unwrap();
*debug_mode = true;
println!("Thread {} enabled debug mode.", i);
} else {
let debug_mode = config.debug_mode.read().unwrap();
println!("Thread {} read debug mode: {}", i, *debug_mode);
}
})
})
.collect();
for handle in handles {
handle.join().unwrap();
}
}このコードでは、偶数スレッドがwriteロックを取得して書き込みを行い、奇数スレッドがreadロックを取得して値を読み取っています。
Arcで共有所有権を実現
スレッド間で安全にデータを共有するためには、MutexやRwLockをArc（Atomic Reference Counting）でラップして共有所有権を持たせる必要があります。
use std::sync::{Arc, Mutex};
use std::thread;
struct Config {
max_connections: Mutex<u32>,
}
fn main() {
let config = Arc::new(Config {
max_connections: Mutex::new(100),
});
let handles: Vec<_> = (0..10)
.map(|_| {
let config = Arc::clone(&config);
thread::spawn(move || {
let mut max_connections = config.max_connections.lock().unwrap();
*max_connections += 1;
println!("Updated max_connections: {}", *max_connections);
})
})
.collect();
for handle in handles {
handle.join().unwrap();
}
}この例では、Arcを使ってConfigのインスタンスを複数のスレッド間で安全に共有しています。
スレッドセーフ設計の注意点
- 同期の適切な選択:
Mutexは単純な排他制御に適し、RwLockは同時読み取りを許可する場合に便利です。 - ロックのスコープを最小限に: ロックの保持時間を短くすることで、スレッドの競合を減らします。
- デッドロックの回避: 複数のロックを使う場合は、取得順序を統一するなどの工夫をしましょう。
応用例: スレッドセーフなカウンタ
以下は、ArcとMutexを活用したスレッドセーフなカウンタの実装例です。
use std::sync::{Arc, Mutex};
use std::thread;
struct Counter {
count: Mutex<u32>,
}
fn main() {
let counter = Arc::new(Counter {
count: Mutex::new(0),
});
let handles: Vec<_> = (0..10)
.map(|_| {
let counter = Arc::clone(&counter);
thread::spawn(move || {
let mut count = counter.count.lock().unwrap();
*count += 1;
})
})
.collect();
for handle in handles {
handle.join().unwrap();
}
println!("Final count: {}", counter.count.lock().unwrap());
}このカウンタは、複数のスレッドから安全にインクリメントでき、最終的な値を取得できます。
まとめ
- マルチスレッド環境では、
MutexやRwLockを活用してデータの安全性を確保します。 - データの共有には
Arcを使用して所有権を管理します。 - 適切な同期プリミティブを選択し、デッドロックを避ける設計を心がけましょう。
次に、学んだ内容を確認するための演習問題を紹介します。
演習問題：構造体のフィールド変更を実装する
これまで学んだ内容を実践するための演習問題を紹介します。各問題では、Rustでの構造体の可変性や安全なフィールド変更に関する知識を活用します。
演習1: 動的に変更可能な構造体
以下の構造体を定義し、フィールドを動的に変更できるようにしてください。
また、設定をリセットする関数も実装してください。
struct Settings {
debug_mode: bool,
max_connections: u32,
}
// 要件:
// 1. debug_modeを動的に切り替えられるようにする
// 2. max_connectionsを動的に設定できるようにする
// 3. 設定を初期値に戻すreset_settings関数を実装する期待される動作:
debug_modeをtrueやfalseに切り替え可能。max_connectionsを任意の値に変更可能。reset_settingsを呼び出すと、初期値debug_mode: false、max_connections: 100に戻る。
演習2: スレッドセーフな設定変更
次の構造体を定義し、複数スレッドから安全に設定を変更できるようにしてください。
struct Config {
mode: String,
max_threads: u32,
}
// 要件:
// 1. Config構造体のフィールドを安全に変更する
// 2. `mode`フィールドを"Normal"や"Debug"に切り替えられるようにする
// 3. `max_threads`フィールドを任意の値に設定可能にする
// 4. 複数スレッドで同時にフィールドにアクセスできるようにするヒント:
MutexやRwLockを使用してフィールドを保護します。Arcを利用して構造体を複数のスレッドで共有します。
演習3: 内部可変性を活用した履歴管理
履歴を追跡できる構造体を実装してください。
struct Logger {
history: Vec<String>,
}
// 要件:
// 1. 新しいログメッセージを追加できるようにする
// 2. すべてのログ履歴を取得できるようにする
// 3. 内部可変性を活用して、複数の関数から安全に操作可能にする期待される動作:
add_log(message: &str)で新しいログメッセージを追加。get_history()ですべてのログ履歴を取得可能。
ヒント:
- 内部可変性には
RefCellを使用します。 - 必要に応じて
Rcで所有権を共有します。
演習4: カスタム同期構造体
以下の機能を持つ同期構造体を設計してください。
struct Counter {
count: u32,
}
// 要件:
// 1. スレッドセーフにカウンタをインクリメントできる
// 2. カウンタの現在値を取得できる
// 3. リセット機能を追加する期待される動作:
- 複数スレッドから同時にカウンタを更新可能。
reset()を呼び出すとカウンタが0に戻る。
ヒント:
MutexとArcを活用します。
解答のチェック方法
- コードをコンパイルし、エラーがないことを確認します。
- テストケースを作成して期待される動作を検証します。
- スレッドセーフ性のあるコードでは、複数スレッドを利用したテストを行いましょう。
これらの演習を通じて、構造体の可変性と安全性を考慮した設計に慣れることができます。次に、学んだ内容を振り返るまとめを提示します。
まとめ
本記事では、Rustにおける構造体のフィールドを変更可能にする方法とその制約について解説しました。mutキーワードを用いた基本的な変更から、Cell型やRefCell型による内部可変性の活用、そしてマルチスレッド環境でのスレッドセーフな設計方法まで、幅広いトピックを扱いました。
特に、Rustの所有権と借用ルールを遵守しながら安全に変更を行う設計が重要であることを学びました。また、実用例や演習問題を通じて、実際のプロジェクトで役立つ知識とスキルを習得できたはずです。
構造体の可変性を正しく管理することで、より堅牢で安全なコードを書けるようになります。これからもRustの特性を活かしたプログラム設計に挑戦してください！
コメント