MENU
  1. ホーム
  2. Rust
  3. Rustでクロスプラットフォーム対応コードを設計・デバッグするための完全ガイド

Rustでクロスプラットフォーム対応コードを設計・デバッグするための完全ガイド

Rust

Rustは、高速かつ安全なシステムプログラミング言語として注目されています。その魅力の一つがクロスプラットフォーム対応であり、Windows、macOS、Linuxといった複数のOSで同じコードベースからアプリケーションを構築できる点です。しかし、クロスプラットフォーム開発には、OSごとの違いを考慮した設計や、適切なデバッグ手法が不可欠です。

本記事では、Rustを使用してクロスプラットフォーム対応コードを効率的に設計し、デバッグするための具体的なポイントやツールを解説します。設計手法からデバッグツール、依存関係の管理、よくある問題とその解決法まで、実践的な内容を網羅します。Rustを使ったクロスプラットフォーム開発に挑戦する際の参考にしてください。

目次
  1. クロスプラットフォーム対応の重要性
    1. 複数OS対応の必要性
    2. 開発コストの削減
    3. ソフトウェア品質向上
  2. Rustがクロスプラットフォームに適している理由
    1. システムレベルのパフォーマンスと安全性
    2. 豊富な標準ライブラリ
    3. Cargoによる依存関係管理
    4. 条件付きコンパイルのサポート
    5. 豊富なクロスプラットフォーム開発ツール
  3. クロスプラットフォーム対応の設計手法
    1. プラットフォーム依存コードの分離
    2. 抽象化レイヤーの導入
    3. 条件付きコンパイルの活用
    4. クロスプラットフォームライブラリの活用
    5. テスト環境の統一
  4. 条件付きコンパイルの活用法
    1. `cfg`属性の基本的な使い方
    2. 関数単位の条件付きコンパイル
    3. 複数条件の組み合わせ
    4. 条件付きモジュールの定義
    5. ビルド時にカスタム条件を指定する
    6. 注意点
  5. クロスプラットフォームデバッグツールの紹介
    1. 1. `gdb`（GNU Debugger）
    2. 2. `lldb`（LLVM Debugger）
    3. 3. `Visual Studio Code`（VSCode）
    4. 4. `Delve`（Linux, macOS用のデバッガ）
  6. クロスプラットフォームの依存関係管理
    1. Cargoによる依存関係管理
    2. プラットフォームごとの依存関係の指定
    3. ビルド時の依存関係オプション
    4. 依存関係のバージョン管理
    5. クロスコンパイルと依存関係
    6. 依存関係のロックファイル
    7. 依存関係の確認と削除
  7. よくあるデバッグの問題とその解決法
    1. 1. パスの違いによるエラー
    2. 2. 依存ライブラリの非互換性
    3. 3. 改行コードの違い
    4. 4. 環境変数やシステムコールの違い
    5. 5. ビルドツールの依存関係エラー
    6. 6. コンパイルエラーのトラブルシューティング
    7. 7. デバッグシンボルが含まれない問題
  8. 実際のコード例と応用
    1. 1. クロスプラットフォームなファイル操作
    2. 2. クロスプラットフォームなHTTPリクエスト
    3. 3. 条件付きコンパイルを使ったOS固有の処理
    4. 4. クロスコンパイルの実践
    5. 5. 実践的なエラーハンドリング
  9. まとめ

クロスプラットフォーム対応の重要性


ソフトウェア開発において、クロスプラットフォーム対応はますます重要になっています。複数のOSや環境で同じプログラムが動作することで、ユーザー層の拡大や開発コストの削減が可能になります。

複数OS対応の必要性

  • ユーザー層の拡大：Windows、macOS、Linuxの各OSに対応することで、より多くのユーザーに利用してもらえます。
  • 一貫性のあるユーザー体験：複数のプラットフォームで同じ機能や操作性を提供することで、ユーザーに統一された体験を届けられます。
  • ビジネス要件：企業では異なるOSを使用していることが一般的であり、クロスプラットフォーム対応のソフトウェアが求められることが多いです。

開発コストの削減


1つのコードベースで複数のプラットフォームに対応できれば、開発時間やメンテナンスコストを削減できます。個別にOSごとの開発を行う必要がなくなり、効率的に開発リソースを活用できます。

ソフトウェア品質向上


クロスプラットフォーム対応を考慮することで、コードの可搬性や保守性が向上します。OS固有の依存関係を分離し、設計をしっかり行うことで、バグの発生を抑えることができます。

クロスプラットフォーム対応は、ユーザーの利便性向上や開発効率を高めるために、現代のソフトウェア開発において欠かせない要素となっています。

Rustがクロスプラットフォームに適している理由

Rustは、クロスプラットフォーム開発に最適なプログラミング言語です。その理由は、言語の特性やエコシステムが複数のプラットフォームを効率的にサポートしているからです。

システムレベルのパフォーマンスと安全性


Rustはシステムプログラミング言語として、C/C++と同等のパフォーマンスを持ちながら、メモリ安全性やデータ競合防止を保証しています。これにより、複数のプラットフォームでパフォーマンスを犠牲にせず、安全に動作するアプリケーションが作成できます。

豊富な標準ライブラリ


Rustの標準ライブラリは、OS非依存のAPIが多く、同じコードでWindows、macOS、Linuxなどさまざまなプラットフォームに対応できます。例えば、ファイル操作やネットワーク通信は、標準ライブラリを使えばOSごとの違いを意識する必要がありません。

Cargoによる依存関係管理


Rustのビルドツール兼パッケージマネージャであるCargoは、クロスプラットフォーム向けの依存関係管理をサポートしています。Cargoを使えば、プラットフォームごとに異なる依存ライブラリを管理しやすく、ビルドの自動化が簡単に行えます。

条件付きコンパイルのサポート


Rustは、cfg属性による条件付きコンパイルをサポートしているため、特定のプラットフォームに依存するコードを簡単に切り替えられます。これにより、1つのコードベースで複数のOSに対応することが容易になります。

豊富なクロスプラットフォーム開発ツール


Rustには、crossやrustupといったクロスコンパイルをサポートするツールが充実しています。これにより、開発者は1台のマシンから複数のプラットフォーム向けのビルドが可能です。

Rustの言語設計とエコシステムにより、クロスプラットフォーム対応のアプリケーションを効率的に開発し、高品質なソフトウェアを提供できます。

クロスプラットフォーム対応の設計手法

クロスプラットフォーム対応のソフトウェアを設計する際には、プラットフォームごとの違いを適切に考慮し、柔軟性と保守性を高めることが重要です。Rustでは、いくつかの設計手法を用いることで効率的にクロスプラットフォーム対応が可能です。

プラットフォーム依存コードの分離


プラットフォーム固有の処理を一般的なコードから分離し、専用のモジュールや関数にまとめます。これにより、コードの見通しが良くなり、保守しやすくなります。

#[cfg(target_os = "windows")]
fn platform_specific_function() {
    println!("This is Windows-specific code.");
}

#[cfg(target_os = "linux")]
fn platform_specific_function() {
    println!("This is Linux-specific code.");
}

抽象化レイヤーの導入


プラットフォームごとの処理を抽象化し、共通のインターフェースを定義します。抽象化レイヤーを通じて操作することで、プラットフォームごとの違いを意識せずに開発が進められます。

trait FileHandler {
    fn open_file(&self, path: &str);
}

struct WindowsFileHandler;
impl FileHandler for WindowsFileHandler {
    fn open_file(&self, path: &str) {
        println!("Opening file on Windows: {}", path);
    }
}

struct LinuxFileHandler;
impl FileHandler for LinuxFileHandler {
    fn open_file(&self, path: &str) {
        println!("Opening file on Linux: {}", path);
    }
}

条件付きコンパイルの活用


Rustのcfg属性を使用することで、コンパイル時に特定のプラットフォーム用コードを有効化できます。これにより、1つのコードベースで複数のOSに対応できます。

fn main() {
    #[cfg(target_os = "windows")]
    println!("Running on Windows");

    #[cfg(target_os = "macos")]
    println!("Running on macOS");

    #[cfg(target_os = "linux")]
    println!("Running on Linux");
}

クロスプラットフォームライブラリの活用


外部ライブラリを活用して、OS非依存の機能を実現することが可能です。例えば、ファイルシステム操作にはtokioやasync-std、GUI開発にはdruidやeguiといったクロスプラットフォーム対応ライブラリがあります。

テスト環境の統一


複数のプラットフォームでテストを実施し、一貫した品質を保つようにします。CI/CDパイプラインを設定し、Windows、Linux、macOSの各環境でビルドとテストを自動化すると効率的です。

クロスプラットフォーム対応を考慮した設計を行うことで、効率的に保守性の高いアプリケーションを開発でき、長期的な運用がしやすくなります。

条件付きコンパイルの活用法

Rustでは、複数のプラットフォームに対応するために条件付きコンパイルを活用できます。条件付きコンパイルを使用することで、特定のプラットフォーム向けに異なるコードを記述し、同じコードベースで複数の環境をサポートできます。

`cfg`属性の基本的な使い方

cfg属性を使って、特定の条件下でのみコンパイルされるコードを指定できます。以下のように、OSごとの処理を切り替えることが可能です。

fn main() {
    #[cfg(target_os = "windows")]
    println!("Running on Windows");

    #[cfg(target_os = "linux")]
    println!("Running on Linux");

    #[cfg(target_os = "macos")]
    println!("Running on macOS");
}

関数単位の条件付きコンパイル

関数全体に条件を適用することもできます。例えば、Windows専用の関数やLinux専用の関数を定義する場合です。

#[cfg(target_os = "windows")]
fn platform_specific_function() {
    println!("This function runs only on Windows.");
}

#[cfg(target_os = "linux")]
fn platform_specific_function() {
    println!("This function runs only on Linux.");
}

fn main() {
    platform_specific_function();
}

複数条件の組み合わせ

複数の条件を組み合わせて指定することもできます。anyやallを使って複合条件を表現できます。

#[cfg(any(target_os = "windows", target_os = "macos"))]
fn run_on_windows_or_macos() {
    println!("Running on either Windows or macOS.");
}

fn main() {
    run_on_windows_or_macos();
}

条件付きモジュールの定義

モジュール全体を条件付きでコンパイルすることも可能です。これにより、プラットフォームごとに異なるモジュールを読み込めます。

#[cfg(target_os = "windows")]
mod windows_module {
    pub fn run() {
        println!("Windows-specific module.");
    }
}

#[cfg(target_os = "linux")]
mod linux_module {
    pub fn run() {
        println!("Linux-specific module.");
    }
}

fn main() {
    #[cfg(target_os = "windows")]
    windows_module::run();

    #[cfg(target_os = "linux")]
    linux_module::run();
}

ビルド時にカスタム条件を指定する

Cargo.tomlのfeaturesやbuild.rsを活用することで、ビルド時にカスタム条件を指定できます。

Cargo.tomlの例:

[features]
custom_feature = []

コード内の例:

#[cfg(feature = "custom_feature")]
fn custom_feature_function() {
    println!("Custom feature is enabled.");
}

fn main() {
    custom_feature_function();
}

注意点

  • 冗長な条件指定を避ける：複雑な条件分岐はコードの可読性を下げるため、必要最低限にとどめるようにしましょう。
  • テストの徹底：異なるプラットフォームでしっかりとテストを行い、条件付きコンパイルが正しく機能することを確認しましょう。

条件付きコンパイルを適切に活用することで、効率的にクロスプラットフォーム対応コードを管理でき、柔軟なソフトウェア開発が可能になります。

クロスプラットフォームデバッグツールの紹介

Rustでクロスプラットフォーム対応のコードを開発する際、効率的にデバッグを行うためには、適切なデバッグツールの活用が欠かせません。ここでは、主要なデバッグツールとその特徴、使い方について解説します。

1. `gdb`（GNU Debugger）

gdbはLinuxおよびmacOSで広く使用されるデバッガです。Rustプログラムのステップ実行やブレークポイントの設定が可能です。

インストール方法：
Linux（Debian系）では次のコマンドでインストールします。

sudo apt-get install gdb

基本的な使い方：

rustc -g program.rs     # デバッグシンボルを含めてコンパイル
gdb ./program           # gdbを起動

2. `lldb`（LLVM Debugger）

lldbは、macOSおよびLinuxで利用できるデバッガで、gdbに代わるモダンなデバッグツールです。XcodeやRustのrust-lldbと一緒に利用されます。

インストール方法：
macOSではXcode Command Line Toolsに含まれています。

xcode-select --install

基本的な使い方：

rustc -g program.rs     # デバッグシンボルを含めてコンパイル
lldb ./program          # lldbを起動

3. `Visual Studio Code`（VSCode）

VSCodeはクロスプラットフォーム対応の統合開発環境（IDE）で、Rustのデバッグに非常に適しています。CodeLLDB拡張機能をインストールすることで、デバッグ機能を強化できます。

手順：

  1. VSCodeをインストール
  2. 拡張機能「CodeLLDB」を追加
  3. launch.jsonファイルでデバッグ設定を行います。

launch.jsonの例:

{
    "configurations": [
        {
            "name": "Debug Rust Program",
            "type": "lldb",
            "request": "launch",
            "program": "${workspaceFolder}/target/debug/your_program",
            "args": [],
            "cwd": "${workspaceFolder}"
        }
    ]
}

4. `Delve`（Linux, macOS用のデバッガ）

DelveはGo向けのデバッガですが、Rustにも活用できます。効率的なステップ実行や変数の確認が可能です。

クロスプラットフォームの依存関係管理

Rustでクロスプラットフォーム対応のソフトウェアを開発する際、依存関係管理は重要なポイントです。依存関係を適切に管理することで、異なるプラットフォームでのビルドや実行をスムーズに行えます。Rustでは、主にCargoを使用して依存関係を管理します。

Cargoによる依存関係管理

CargoはRustのビルドシステム兼パッケージマネージャです。依存関係を簡単に追加・管理でき、クロスプラットフォームの開発をサポートします。

Cargo.tomlで依存関係を指定する例：

[dependencies]
serde = "1.0"         # シリアライズ/デシリアライズ用ライブラリ
tokio = { version = "1", features = ["full"] }  # 非同期ランタイム

プラットフォームごとの依存関係の指定

Cargoでは、特定のプラットフォーム向けに依存関係を指定できます。targetを使用することで、OSごとに異なる依存関係を適用できます。

Cargo.tomlでの条件付き依存関係の例：

[target.'cfg(target_os = "windows")'.dependencies]
winapi = "0.3"   # Windows専用の依存関係

[target.’cfg(target_os = “linux”)’.dependencies]

libc = “0.2” # Linux専用の依存関係

ビルド時の依存関係オプション

Cargoのfeaturesを使うことで、ビルド時にオプション機能を切り替えられます。これにより、クロスプラットフォームでの柔軟なビルドが可能です。

Cargo.tomlでのfeatures定義：

[dependencies]
some_crate = { version = "1.0", optional = true }

[features]

default = [] use_some_crate = [“some_crate”]

ビルド時にfeatureを有効にする例：

cargo build --features "use_some_crate"

依存関係のバージョン管理

依存関係のバージョン指定には、セマンティックバージョニングが使用されます。

  • 正確なバージョン：serde = "1.0.136"
  • 互換性を考慮：serde = "1.0"（1.x.xが適用）
  • 範囲指定：serde = ">=1.0, <2.0"

クロスコンパイルと依存関係

Rustはクロスコンパイルをサポートしており、rustupとcargoを使用して異なるターゲット向けにビルドできます。

例：Linux向けバイナリをWindowsでビルド：

rustup target add x86_64-unknown-linux-gnu
cargo build --target x86_64-unknown-linux-gnu

ターゲットに必要な依存関係は、事前にインストールしておきましょう。

依存関係のロックファイル

CargoはCargo.lockファイルを生成し、依存関係のバージョンを固定します。これにより、異なる環境で同じ依存バージョンを使用できます。

cargo check   # 依存関係の整合性を確認
cargo update  # 依存関係のバージョンを更新

依存関係の確認と削除

依存関係の確認には次のコマンドを使用します。

cargo tree    # 依存関係ツリーを表示
cargo remove <crate_name>   # 依存関係を削除（cargo-editが必要）

適切な依存関係管理を行うことで、クロスプラットフォーム開発におけるビルドの問題を減らし、効率的に高品質なRustプログラムを開発できます。

よくあるデバッグの問題とその解決法

Rustでクロスプラットフォーム開発を行うと、OSごとの違いや依存関係、ビルド環境によってさまざまな問題が発生します。ここでは、よくあるデバッグの問題とその具体的な解決法について解説します。

1. パスの違いによるエラー

異なるOSではファイルパスの形式が異なります。Windowsはバックスラッシュ \ を使用し、LinuxやmacOSはスラッシュ / を使用します。

問題の例：

let path = "C:\\Users\\username\\file.txt";  // Windows用のパス

解決法：
std::path::Pathやstd::path::PathBufを使用して、OSに依存しないパスを作成します。

use std::path::Path;

let path = Path::new("C:/Users/username/file.txt");  // OSに応じたパスに変換

2. 依存ライブラリの非互換性

外部ライブラリが特定のOSでのみサポートされている場合、ビルド時にエラーが発生することがあります。

解決法：
cfg属性を使用して、特定のプラットフォームのみで依存関係を有効にします。

Cargo.tomlの例：

[target.'cfg(target_os = "windows")'.dependencies]
winapi = "0.3"

[target.’cfg(target_os = “linux”)’.dependencies]

libc = “0.2”

3. 改行コードの違い

Windowsでは改行コードが\r\n、LinuxやmacOSでは\nです。文字列の比較やファイル処理で問題になることがあります。

解決法：
Rustのstd::fsやstd::ioを使用することで、改行コードを自動的に適切な形式に処理できます。また、正規表現で改行コードを統一する方法も有効です。

let text = text.replace("\r\n", "\n");  // 改行コードを`\n`に統一

4. 環境変数やシステムコールの違い

異なるOSでは環境変数の取得やシステムコールが異なります。

解決法：
std::envモジュールを使用して環境変数を取得し、プラットフォームごとに分岐処理を行います。

use std::env;

fn get_home_dir() {
    #[cfg(target_os = "windows")]
    println!("Home directory: {:?}", env::var("USERPROFILE"));

    #[cfg(target_os = "linux")]
    println!("Home directory: {:?}", env::var("HOME"));
}

5. ビルドツールの依存関係エラー

クロスコンパイル時、ターゲットプラットフォーム用の依存ツールが見つからない場合があります。

解決法：
必要なターゲットツールチェーンやライブラリを事前にインストールします。

例：Linux向けビルドをWindowsで行う場合：

rustup target add x86_64-unknown-linux-gnu
sudo apt-get install gcc-multilib

6. コンパイルエラーのトラブルシューティング

Rustのコンパイルエラーメッセージは詳細ですが、特に初心者には難解に感じることがあります。

解決法：

  • エラーメッセージをよく読む：エラーの内容やヒントを確認します。
  • Rustコンパイラの--verboseオプションを使用して詳細な情報を確認します。
  cargo build --verbose
  • cargo check でコンパイルせずにエラーを確認します。
  cargo check

7. デバッグシンボルが含まれない問題

デバッグ時にシンボル情報が欠落していると、変数の内容が確認できません。

解決法：
デバッグシンボルを含めてコンパイルします。

cargo build --debug

クロスプラットフォーム開発では、これらの問題に直面する可能性が高いため、適切なデバッグ手法とツールを活用して効率よく問題を解決しましょう。

実際のコード例と応用

Rustでクロスプラットフォーム対応のコードを書く際には、設計手法やデバッグテクニックを理解するだけでなく、具体的なコード例を参考にすることが効果的です。ここでは、ファイル操作やネットワーク通信など、実践的なクロスプラットフォーム対応コードの例を紹介します。

1. クロスプラットフォームなファイル操作

ファイルの読み書きは、OSに依存しない形でRustの標準ライブラリを使うことで実現できます。

use std::fs::File;
use std::io::{Read, Write};
use std::path::PathBuf;

fn write_to_file(file_name: &str, content: &str) {
    let mut path = PathBuf::new();
    path.push(file_name);

    let mut file = File::create(&path).expect("Failed to create file");
    file.write_all(content.as_bytes()).expect("Failed to write to file");
}

fn read_from_file(file_name: &str) -> String {
    let mut path = PathBuf::new();
    path.push(file_name);

    let mut file = File::open(&path).expect("Failed to open file");
    let mut content = String::new();
    file.read_to_string(&mut content).expect("Failed to read file");
    content
}

fn main() {
    let file_name = "example.txt";
    write_to_file(file_name, "Hello, Rust!");
    let content = read_from_file(file_name);
    println!("File content: {}", content);
}

このコードは、Windows、Linux、macOSで動作します。

2. クロスプラットフォームなHTTPリクエスト

reqwestクレートを使用すると、HTTPリクエストを簡単に実行できます。

Cargo.tomlに依存関係を追加：

[dependencies]
reqwest = { version = "0.11", features = ["blocking"] }

HTTPリクエストのコード例：

use reqwest::blocking::get;
use std::error::Error;

fn fetch_url(url: &str) -> Result<String, Box<dyn Error>> {
    let response = get(url)?.text()?;
    Ok(response)
}

fn main() {
    let url = "https://www.rust-lang.org";
    match fetch_url(url) {
        Ok(content) => println!("Fetched content:\n{}", content),
        Err(e) => eprintln!("Error fetching URL: {}", e),
    }
}

このコードは、Windows、Linux、macOSで同じように動作します。

3. 条件付きコンパイルを使ったOS固有の処理

異なるOSに対して異なる処理を実行する例です。

fn main() {
    #[cfg(target_os = "windows")]
    {
        println!("Running on Windows");
    }

    #[cfg(target_os = "linux")]
    {
        println!("Running on Linux");
    }

    #[cfg(target_os = "macos")]
    {
        println!("Running on macOS");
    }
}

このように、OSごとに異なる処理を分けることで、クロスプラットフォーム対応が容易になります。

4. クロスコンパイルの実践

Rustはクロスコンパイルがサポートされているため、Windows、Linux、macOS向けに1つのマシンでビルドできます。

Linux向けにクロスコンパイルする例（Windows上で実行）：

rustup target add x86_64-unknown-linux-gnu
cargo build --target x86_64-unknown-linux-gnu

5. 実践的なエラーハンドリング

クロスプラットフォーム対応では、エラー処理を丁寧に行うことで、予期しない動作を防ぐことができます。

use std::fs::File;
use std::io::{self, Read};

fn read_file(path: &str) -> Result<String, io::Error> {
    let mut file = File::open(path)?;
    let mut content = String::new();
    file.read_to_string(&mut content)?;
    Ok(content)
}

fn main() {
    match read_file("example.txt") {
        Ok(content) => println!("File content:\n{}", content),
        Err(e) => eprintln!("Failed to read file: {}", e),
    }
}

これらのコード例と応用を理解することで、Rustを使ったクロスプラットフォーム開発の実践力が高まります。さまざまなプラットフォームでテストを行い、柔軟性と信頼性の高いソフトウェアを構築しましょう。

まとめ

本記事では、Rustを用いたクロスプラットフォーム対応コードの設計とデバッグのポイントについて解説しました。クロスプラットフォーム対応の重要性から、Rustが適している理由、設計手法、条件付きコンパイルの活用法、デバッグツール、依存関係の管理、そして実際のコード例までを網羅しました。

Rustの特徴である安全性や高パフォーマンス、豊富なエコシステムを活かせば、複数のOSに対応した堅牢なソフトウェアを効率よく開発できます。プラットフォームごとの違いを考慮し、適切なツールやテクニックを活用することで、開発の効率と品質を向上させましょう。

クロスプラットフォーム開発のスキルを習得し、Rustを使った実践的なプロジェクトにぜひ挑戦してみてください。

Rust

コメント

コメントする

目次
  1. クロスプラットフォーム対応の重要性
    1. 複数OS対応の必要性
    2. 開発コストの削減
    3. ソフトウェア品質向上
  2. Rustがクロスプラットフォームに適している理由
    1. システムレベルのパフォーマンスと安全性
    2. 豊富な標準ライブラリ
    3. Cargoによる依存関係管理
    4. 条件付きコンパイルのサポート
    5. 豊富なクロスプラットフォーム開発ツール
  3. クロスプラットフォーム対応の設計手法
    1. プラットフォーム依存コードの分離
    2. 抽象化レイヤーの導入
    3. 条件付きコンパイルの活用
    4. クロスプラットフォームライブラリの活用
    5. テスト環境の統一
  4. 条件付きコンパイルの活用法
    1. `cfg`属性の基本的な使い方
    2. 関数単位の条件付きコンパイル
    3. 複数条件の組み合わせ
    4. 条件付きモジュールの定義
    5. ビルド時にカスタム条件を指定する
    6. 注意点
  5. クロスプラットフォームデバッグツールの紹介
    1. 1. `gdb`（GNU Debugger）
    2. 2. `lldb`（LLVM Debugger）
    3. 3. `Visual Studio Code`（VSCode）
    4. 4. `Delve`（Linux, macOS用のデバッガ）
  6. クロスプラットフォームの依存関係管理
    1. Cargoによる依存関係管理
    2. プラットフォームごとの依存関係の指定
    3. ビルド時の依存関係オプション
    4. 依存関係のバージョン管理
    5. クロスコンパイルと依存関係
    6. 依存関係のロックファイル
    7. 依存関係の確認と削除
  7. よくあるデバッグの問題とその解決法
    1. 1. パスの違いによるエラー
    2. 2. 依存ライブラリの非互換性
    3. 3. 改行コードの違い
    4. 4. 環境変数やシステムコールの違い
    5. 5. ビルドツールの依存関係エラー
    6. 6. コンパイルエラーのトラブルシューティング
    7. 7. デバッグシンボルが含まれない問題
  8. 実際のコード例と応用
    1. 1. クロスプラットフォームなファイル操作
    2. 2. クロスプラットフォームなHTTPリクエスト
    3. 3. 条件付きコンパイルを使ったOS固有の処理
    4. 4. クロスコンパイルの実践
    5. 5. 実践的なエラーハンドリング
  9. まとめ