MENU
  1. ホーム
  2. Rust
  3. RustでC言語のグローバル変数を操作する方法を詳しく解説

RustでC言語のグローバル変数を操作する方法を詳しく解説

Rust

RustとC言語の連携は、プログラミングにおいて柔軟性を大幅に向上させます。その中でも、C言語のグローバル変数をRustから操作する技術は、既存のCコードをRustで再利用したい場合に非常に役立ちます。しかし、異なる言語間でデータを共有する際には、注意すべき点や特有の課題も存在します。本記事では、FFI（Foreign Function Interface）の基本から、Rustを用いてC言語のグローバル変数を操作する具体的な方法まで、初心者にもわかりやすく解説していきます。この記事を通じて、RustとCの相互運用性を効果的に活用できるようになりましょう。

目次
  1. FFI（Foreign Function Interface）とは
    1. FFIの基本的な役割
    2. RustのFFIサポート
    3. FFIを利用する際の注意点
  2. RustでFFIを利用するための準備
    1. Rustのプロジェクトを作成する
    2. 必要なCコードを準備する
    3. CコードをRustにリンクする
    4. `build.rs`でビルド設定を追加する
    5. `Cargo.toml`の設定
    6. Rustコードに外部シンボルを定義する
  3. C言語でのグローバル変数の定義
    1. グローバル変数の基本的な定義
    2. グローバル変数の特徴
    3. 他のファイルからグローバル変数にアクセスする
    4. グローバル変数を使用する際の注意点
  4. RustからCのグローバル変数にアクセスする方法
    1. Cコードの準備
    2. Rustでの準備
    3. RustとCの連携
    4. 実行結果
    5. 注意点
  5. グローバル変数の安全な操作のためのRustの工夫
    1. 1. グローバル変数へのアクセスをラップする
    2. 2. マルチスレッド環境での競合防止
    3. 3. 型の互換性を確保する
    4. 4. `unsafe`コードの最小化
    5. 5. テストを活用する
    6. まとめ
  6. 具体的なコード例：CとRustの連携
    1. Cコードの準備
    2. Rustコードの準備
    3. `Cargo.toml`と`build.rs`の設定
    4. コードのビルドと実行
    5. 実行結果
    6. 重要なポイント
  7. 実践：C言語のグローバル変数をRustで書き換える
    1. Cコードの定義
    2. RustコードでCのグローバル変数を操作
    3. `Cargo.toml`と`build.rs`の設定
    4. コードのビルドと実行
    5. 実行結果
    6. 解説
    7. 応用例
  8. よくあるエラーとその対処法
    1. 1. シンボルの未定義エラー
    2. 2. メモリ安全性の問題
    3. 3. 型の不一致エラー
    4. 4. リンクエラー（ライブラリが見つからない）
    5. 5. グローバル変数の競合
    6. 6. デバッグが難しい問題
    7. まとめ
  9. まとめ

FFI（Foreign Function Interface）とは


FFI（Foreign Function Interface）は、異なるプログラミング言語間で関数やデータをやり取りする仕組みを指します。Rustにおいては、FFIを利用することでCやC++といった他の言語で書かれたコードを呼び出したり、逆にRustのコードを外部から利用したりできます。

FFIの基本的な役割


FFIの役割は、以下のような点にまとめられます：

  • 既存資産の再利用：既にCやC++で書かれたライブラリをRustから使用できるようにする。
  • 言語間の連携：RustとCの間でデータをやり取りし、複雑な機能を統合する。
  • 性能の向上：Rustの安全性とCのパフォーマンスを組み合わせることで、効率的なプログラムを構築できる。

RustのFFIサポート


RustはFFIのサポートを標準ライブラリに組み込んでおり、外部のCコードを簡単に扱えます。externキーワードを用いることで、C言語の関数や変数をRustコードにインポートすることが可能です。また、#[repr(C)]アトリビュートを使用することで、Rust側でC言語と互換性のあるデータ構造を定義できます。

FFIを利用する際の注意点


FFIは便利な反面、以下のようなリスクや制約があります：

  • 安全性の確保：Rustのメモリ安全性はFFIを通じて操作されるCコードには適用されないため、バグやセキュリティリスクに注意が必要です。
  • データ型の互換性：RustとCで異なる型表現を使用する場合、明示的に変換を行う必要があります。
  • デバッグの難しさ：言語間の境界でエラーが発生した場合、原因を特定するのが難しいことがあります。

FFIを理解し適切に利用することで、Rustの安全性と他言語の柔軟性を組み合わせた強力なソリューションを作成することが可能です。

RustでFFIを利用するための準備

RustからC言語と連携するには、いくつかの準備と設定が必要です。FFIを活用するための基本的な環境構築と注意点を以下にまとめます。

Rustのプロジェクトを作成する


まず、Rustのプロジェクトを作成します。以下のコマンドをターミナルで実行してください：

cargo new ffi_example --bin
cd ffi_example

これにより、FFIに必要なRustプロジェクトが作成されます。

必要なCコードを準備する


FFIを利用するには、Rustが連携する対象となるCコードを用意する必要があります。たとえば、次のようなグローバル変数を持つCコードをexample.cとして保存します：

#include <stdio.h>

int global_var = 42;

void print_global_var() {
    printf("Global variable value: %d\n", global_var);
}

このコードでは、global_varというグローバル変数と、その値を出力する関数が定義されています。

CコードをRustにリンクする


RustでCコードを利用するには、まずCコードをコンパイルしてライブラリを作成します。以下のコマンドで静的ライブラリを生成します：

gcc -c example.c -o example.o
ar rcs libexample.a example.o

これにより、libexample.aという静的ライブラリが生成されます。このライブラリをRustのプロジェクトにリンクします。

`build.rs`でビルド設定を追加する


RustのプロジェクトでCのライブラリを使うために、build.rsファイルを作成し、以下の内容を追加します：

fn main() {
    println!("cargo:rustc-link-search=native=.");
    println!("cargo:rustc-link-lib=static=example");
}

このコードは、Rustに対して静的ライブラリのリンク先を指定します。

`Cargo.toml`の設定


Cargo.tomlに以下の設定を追加して、build.rsをビルドスクリプトとして指定します：

[package]
build = "build.rs"

Rustコードに外部シンボルを定義する


最後に、Rustコード内でCのシンボルを利用できるように宣言します：

extern "C" {
    static mut global_var: i32;
    fn print_global_var();
}

これにより、RustからCのグローバル変数や関数を呼び出す準備が整います。

RustとCのFFI環境を正しく設定することで、効率的に異言語間で連携したプログラムを開発できます。

C言語でのグローバル変数の定義

C言語では、グローバル変数を定義することで、プログラム全体で共有されるデータを管理することができます。このセクションでは、グローバル変数の定義方法とその特徴を解説します。

グローバル変数の基本的な定義


グローバル変数は、関数の外部で定義され、プログラムのどこからでもアクセス可能です。以下の例を見てみましょう：

#include <stdio.h>

// グローバル変数の定義
int global_var = 100;

// グローバル変数の値を表示する関数
void display_global_var() {
    printf("Global variable: %d\n", global_var);
}

このコードでは、global_varという変数がグローバルスコープで定義されており、display_global_var関数内で使用されています。

グローバル変数の特徴

  • スコープ: グローバル変数は、定義されたファイル全体でアクセス可能です。また、他のファイルからも適切に宣言すれば利用できます。
  • 初期化: グローバル変数は、明示的に初期化されていない場合、自動的に0に初期化されます。
  • 寿命: プログラムの実行が終了するまでメモリ上に存在します。

他のファイルからグローバル変数にアクセスする


複数のソースファイルでグローバル変数を使用する場合、以下のようにexternキーワードを用いて宣言します：

ファイル1: main.c

#include <stdio.h>

// 他のファイルで定義されたグローバル変数を参照
extern int global_var;

void modify_global_var(int value) {
    global_var = value;
}

ファイル2: example.c

#include <stdio.h>

// グローバル変数の定義
int global_var = 42;

void display_global_var() {
    printf("Global variable: %d\n", global_var);
}

このように分割したソースファイルをコンパイルしてリンクすることで、複数のファイル間でグローバル変数を共有できます。

グローバル変数を使用する際の注意点

  1. 名前の衝突: グローバル変数は、プログラム全体で名前が衝突するリスクがあります。名前に一意性を持たせることが重要です。
  2. デバッグの困難さ: グローバル変数を多用すると、どのコードがその変数を変更したのかを特定するのが難しくなります。
  3. スレッドセーフではない: マルチスレッド環境では、適切な同期がないとグローバル変数の競合が発生する可能性があります。

適切に設計されたグローバル変数の使用により、プログラムの一貫性と可読性を維持しつつ、共有データを効率的に管理できます。

RustからCのグローバル変数にアクセスする方法

RustでC言語のグローバル変数にアクセスするには、FFI（Foreign Function Interface）を利用します。このセクションでは、RustコードでC言語のグローバル変数を操作する具体的な手順を解説します。

Cコードの準備


まず、RustがアクセスするC言語のグローバル変数を定義します。以下はその例です：

// example.c
#include <stdio.h>

// グローバル変数
int global_var = 42;

// グローバル変数を出力する関数
void print_global_var() {
    printf("Global variable: %d\n", global_var);
}

このコードをコンパイルしてRustがリンクできるようにします。

gcc -c example.c -o example.o
ar rcs libexample.a example.o

Rustでの準備


Rustコード内でCのグローバル変数を利用するために、extern "C"で外部シンボルを宣言します。

// main.rs
extern "C" {
    // グローバル変数を宣言
    static mut global_var: i32;

    // グローバル変数を出力する関数を宣言
    fn print_global_var();
}

fn main() {
    unsafe {
        // Cのグローバル変数を出力する
        print_global_var();

        // グローバル変数を変更
        global_var = 100;

        // 再度出力して変更を確認
        print_global_var();
    }
}

ここで重要なのは、Rustでunsafeブロックを使用してグローバル変数を操作する点です。グローバル変数はスレッドセーフではないため、Rustでは安全性が保証されていません。そのため、unsafeを使って明示的に操作を行います。

RustとCの連携


RustでCコードをビルドするには、以下の手順でCargo.tomlとbuild.rsを設定します。

Cargo.toml

[package]
name = "ffi_example"
version = "0.1.0"
edition = "2021"
build = "build.rs"

[build-dependencies]

[dependencies]

build.rs

fn main() {
    println!("cargo:rustc-link-search=native=.");
    println!("cargo:rustc-link-lib=static=example");
}

この設定により、RustはCの静的ライブラリを正しくリンクできます。

実行結果


コードをビルドして実行します。

cargo run

出力例:

Global variable: 42
Global variable: 100

RustからC言語のグローバル変数の値を取得し、変更できることを確認できます。

注意点

  1. 安全性の考慮: グローバル変数はunsafeであるため、アクセス時には競合やデータ破損のリスクがあります。
  2. 型の互換性: RustとCのデータ型が異なる場合、適切にキャストする必要があります。
  3. ライブラリのリンクミス: ビルド設定でリンクエラーが発生しないよう、正しいファイルパスを指定してください。

これでRustからCのグローバル変数を操作する基本的な方法が理解できます。この知識を活用して、効率的な異言語連携を実現しましょう。

グローバル変数の安全な操作のためのRustの工夫

RustでC言語のグローバル変数を操作する際、安全性を確保することが重要です。Rustは所有権や型システムを通じて安全性を保証しますが、FFIを利用する場合、これらの保証が弱まるため、注意が必要です。このセクションでは、グローバル変数を安全に操作するための具体的な方法を紹介します。

1. グローバル変数へのアクセスをラップする


グローバル変数の直接操作を避け、関数や型を用いてラップすることで、安全性を高められます。以下はその例です：

// グローバル変数をラップする構造体
pub struct GlobalVar;

impl GlobalVar {
    // 値を取得する
    pub fn get() -> i32 {
        unsafe { global_var }
    }

    // 値を設定する
    pub fn set(value: i32) {
        unsafe {
            global_var = value;
        }
    }
}

extern "C" {
    static mut global_var: i32;
}

fn main() {
    // 安全にグローバル変数を操作する
    println!("Initial value: {}", GlobalVar::get());
    GlobalVar::set(123);
    println!("Updated value: {}", GlobalVar::get());
}

このようにすることで、直接unsafeブロックを使用するコードを最小化できます。

2. マルチスレッド環境での競合防止


マルチスレッド環境では、複数のスレッドが同時にグローバル変数にアクセスする可能性があります。これによりデータ競合が発生するため、適切な同期メカニズムを導入します。Rust標準ライブラリのMutexを使用する例を示します：

use std::sync::Mutex;

lazy_static::lazy_static! {
    static ref GLOBAL_VAR_MUTEX: Mutex<i32> = Mutex::new(0);
}

fn get_global_var() -> i32 {
    let var = GLOBAL_VAR_MUTEX.lock().unwrap();
    *var
}

fn set_global_var(value: i32) {
    let mut var = GLOBAL_VAR_MUTEX.lock().unwrap();
    *var = value;
}

fn main() {
    println!("Initial value: {}", get_global_var());
    set_global_var(456);
    println!("Updated value: {}", get_global_var());
}

このコードでは、Mutexによってスレッド間の競合を防止し、安全に操作できるようにしています。

3. 型の互換性を確保する


RustとCのデータ型が異なる場合、型変換が必要です。たとえば、Cのint型はRustのi32に対応しますが、プラットフォームによってサイズが異なる場合があります。その場合、FFIに互換性を持たせるため、正しい型を選択することが重要です。

extern "C" {
    static mut global_var: std::os::raw::c_int;
}

このコードでは、Cの型intに対応するRustのstd::os::raw::c_int型を使用しています。

4. `unsafe`コードの最小化


unsafeコードの範囲を最小限に抑えることで、安全性を向上させられます。unsafeブロック内の操作は必要最小限にし、外部からのアクセスを制限します。

5. テストを活用する


グローバル変数の操作に関する単体テストや統合テストを積極的に導入します。以下はテスト例です：

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn test_global_var_operations() {
        GlobalVar::set(99);
        assert_eq!(GlobalVar::get(), 99);
    }
}

テストによって予期しないバグを未然に防止できます。

まとめ


グローバル変数を安全に操作するためには、以下のような工夫が必要です：

  • ラッパー型や関数を用いる
  • マルチスレッド環境での競合を防ぐ
  • 型の互換性を確保する
  • unsafeコードを最小化する
  • テストで動作を保証する

これらの方法を活用して、Rustで安全にグローバル変数を操作しましょう。

具体的なコード例：CとRustの連携

ここでは、C言語で定義されたグローバル変数と関数をRustで操作する具体的なコード例を示します。CとRustの連携の全体像を理解するのに役立つ内容です。

Cコードの準備


次のようなCコードを用意します。このコードにはグローバル変数と、それを操作する関数が含まれています。

// example.c
#include <stdio.h>

int global_var = 50; // グローバル変数

void print_global_var() {
    printf("Global variable value: %d\n", global_var);
}

void increment_global_var() {
    global_var++;
    printf("Global variable incremented to: %d\n", global_var);
}

このコードをコンパイルして静的ライブラリを作成します。

gcc -c example.c -o example.o
ar rcs libexample.a example.o

Rustコードの準備


RustからCのグローバル変数と関数を利用するため、以下のコードをmain.rsに記述します。

extern "C" {
    // グローバル変数の宣言
    static mut global_var: i32;

    // Cの関数の宣言
    fn print_global_var();
    fn increment_global_var();
}

fn main() {
    unsafe {
        // 初期値を確認
        print_global_var();

        // グローバル変数をRustから変更
        global_var = 100;
        println!("Global variable set to 100 from Rust.");
        print_global_var();

        // Cの関数を呼び出して値を変更
        increment_global_var();
    }
}

このコードでは、unsafeブロックを利用してCのグローバル変数や関数を操作しています。

`Cargo.toml`と`build.rs`の設定

Cargo.toml

[package]
name = "ffi_example"
version = "0.1.0"
edition = "2021"
build = "build.rs"

[dependencies]

build.rs

fn main() {
    println!("cargo:rustc-link-search=native=.");
    println!("cargo:rustc-link-lib=static=example");
}

これにより、RustがCのライブラリを正しくリンクします。

コードのビルドと実行


以下のコマンドでRustコードをビルドし、実行します。

cargo build
cargo run

実行結果

Global variable value: 50
Global variable set to 100 from Rust.
Global variable value: 100
Global variable incremented to: 101

これにより、RustからCのグローバル変数を操作し、その変更を確認できることが示されます。

重要なポイント

  1. extern "C"の使用: RustでCの関数や変数を利用するには、extern "C"を使用します。
  2. unsafeブロックの活用: グローバル変数の操作はunsafeで囲む必要があります。
  3. 型の互換性の確認: Cの型とRustの型が一致することを確認する必要があります。

このコード例を参考にすることで、RustとCを連携させたプロジェクトを構築する具体的なイメージをつかむことができます。

実践：C言語のグローバル変数をRustで書き換える

ここでは、Rustを使用してC言語のグローバル変数を読み取り、変更する実践的な例を紹介します。これにより、RustからCのグローバル変数を安全かつ効率的に操作する方法を学ぶことができます。

Cコードの定義


以下のCコードは、グローバル変数global_varを定義し、その値を操作するための関数を提供します。

// example.c
#include <stdio.h>

// グローバル変数
int global_var = 10;

// グローバル変数の値を出力
void print_global_var() {
    printf("Global variable value: %d\n", global_var);
}

// グローバル変数を増加
void increment_global_var() {
    global_var++;
}

このコードを静的ライブラリにコンパイルします。

gcc -c example.c -o example.o
ar rcs libexample.a example.o

RustコードでCのグローバル変数を操作


次に、RustコードでCのグローバル変数を操作します。

extern "C" {
    // グローバル変数の宣言
    static mut global_var: i32;

    // Cの関数の宣言
    fn print_global_var();
    fn increment_global_var();
}

fn main() {
    unsafe {
        // 現在のグローバル変数の値を出力
        print_global_var();

        // Rustからグローバル変数を直接変更
        global_var = 42;
        println!("Global variable set to 42 in Rust.");

        // 変更を確認
        print_global_var();

        // C関数を使って値を増加
        increment_global_var();
        println!("Incremented global variable using C function.");

        // 最終的な値を出力
        print_global_var();
    }
}

`Cargo.toml`と`build.rs`の設定

Cargo.toml

[package]
name = "ffi_example"
version = "0.1.0"
edition = "2021"
build = "build.rs"

[dependencies]

build.rs

fn main() {
    println!("cargo:rustc-link-search=native=.");
    println!("cargo:rustc-link-lib=static=example");
}

これにより、RustはCライブラリを正しくリンクできます。

コードのビルドと実行


以下のコマンドでコードをビルドし、実行します。

cargo build
cargo run

実行結果


以下は、このコードの実行結果の例です。

Global variable value: 10
Global variable set to 42 in Rust.
Global variable value: 42
Incremented global variable using C function.
Global variable value: 43

解説

  1. unsafeでの操作: Rustでは、FFIを通じた操作がunsafeブロックで囲まれる必要があります。
  2. 値の変更: Rustから直接グローバル変数を変更することで、Cコードの挙動を制御できます。
  3. C関数との併用: Cで提供される関数をRustから呼び出し、グローバル変数の値を間接的に変更することもできます。

応用例


この方法を応用すれば、以下のようなタスクも実現可能です：

  • Rustで動的に設定されるCコードのパラメータを管理。
  • Cコードをラップし、Rust APIとして利用可能にする。

これにより、RustとCの連携をさらに強化できます。RustからCのグローバル変数を安全かつ効率的に操作するスキルを身につけましょう！

よくあるエラーとその対処法

RustとCのFFIを利用する際には、さまざまなエラーが発生する可能性があります。特にグローバル変数の操作に関連するエラーは、デバッグが困難な場合があります。このセクションでは、よくあるエラーとその対処法を具体的に説明します。

1. シンボルの未定義エラー


エラー内容:

undefined reference to `global_var`

原因:
Rustコードで宣言されたCのシンボル（関数やグローバル変数）が正しくリンクされていない可能性があります。

対処法:

  1. Cargo.tomlの設定確認: build.rsでライブラリのリンク先が正しいか確認します。
   fn main() {
       println!("cargo:rustc-link-search=native=.");
       println!("cargo:rustc-link-lib=static=example");
   }
  1. 静的ライブラリの生成確認: Cのコードをコンパイルしてライブラリが正しく生成されているか確認します。
   gcc -c example.c -o example.o
   ar rcs libexample.a example.o

2. メモリ安全性の問題


エラー内容:
プログラムのクラッシュや予期しない動作。Rustの型システムに準拠していないアクセスが原因。

原因:
Rustでunsafeを用いてCのグローバル変数を操作する際、他のスレッドやコードが同時にアクセスすると競合が発生する可能性があります。

対処法:

  1. スレッド間の競合防止: RustのMutexを使用してアクセスを保護します。
   use std::sync::Mutex;

   lazy_static::lazy_static! {
       static ref GLOBAL_VAR: Mutex<i32> = Mutex::new(0);
   }
  1. unsafeコードの範囲を最小化: 必要最低限の操作だけをunsafeブロックで囲むようにします。

3. 型の不一致エラー


エラー内容:

mismatched types
expected `i32`, found `u32`

原因:
RustとCの型が一致していない場合に発生します。

対処法:

  1. 正しい型の使用: RustではCの型を正確に反映する必要があります。Rustのstd::os::rawモジュールを使用することで正しい型を指定できます。
   extern "C" {
       static mut global_var: std::os::raw::c_int;
   }
  1. 型のキャスト: 必要に応じてRustの型をC互換型にキャストします。
   let value: i32 = 42;
   let c_value = value as std::os::raw::c_int;

4. リンクエラー（ライブラリが見つからない）


エラー内容:

ld: library not found for -lexample

原因:
RustがCの静的ライブラリまたは共有ライブラリを見つけられない場合に発生します。

対処法:

  1. リンクパスの確認: build.rsで指定したcargo:rustc-link-searchが正しいディレクトリを指しているか確認します。
  2. ライブラリファイルの存在確認: 静的ライブラリlibexample.aがRustプロジェクトのルートディレクトリにあることを確認します。

5. グローバル変数の競合


エラー内容:
複数のソースファイルで同じ名前のグローバル変数が定義されている場合、リンカーエラーが発生します。

対処法:

  1. externの適切な使用: 他のファイルで使用する場合、externキーワードを使ってグローバル変数を宣言します。
   // main.c
   extern int global_var;
  1. 一貫したヘッダーファイルの使用: グローバル変数を共有する際にはヘッダーファイルを用いて定義を統一します。

6. デバッグが難しい問題


FFIを利用する際、エラーがC側かRust側かを特定するのが難しい場合があります。

対処法:

  1. ロギングの追加: RustとCの両方でロギングを追加して動作を追跡します。
   #include <stdio.h>
   void print_debug(const char *message) {
       printf("DEBUG: %s\n", message);
   }
  1. ツールを活用: gdbやlldbなどのデバッガでRustとCの境界を監視します。

まとめ


RustとCのFFIでは、適切な設定やエラー処理が重要です。シンボルのリンク、型の互換性、安全なメモリアクセスに注意を払い、デバッグツールを活用してトラブルシューティングを行いましょう。これにより、FFIを利用した開発を効率化できます。

まとめ

本記事では、RustとC言語のFFIを利用してグローバル変数を操作する方法について、基本から応用まで詳しく解説しました。FFIの基本概念から、RustでCのグローバル変数を操作する手順、エラーのトラブルシューティング、安全な操作方法までを網羅しました。

RustとCの連携は、既存のCコードを再利用する際に非常に強力です。一方で、型の互換性やメモリの安全性に注意を払う必要があります。unsafeコードの使用を最小限に抑え、適切なラッピングや同期メカニズムを利用することで、安全かつ効率的にRustとCの統合を実現できます。

これらの知識を活用し、RustとCの両方の強みを生かした開発に挑戦してみてください！

Rust
プログラミング グローバル変数 C言語 Rust FFI

コメント

コメントする

目次
  1. FFI（Foreign Function Interface）とは
    1. FFIの基本的な役割
    2. RustのFFIサポート
    3. FFIを利用する際の注意点
  2. RustでFFIを利用するための準備
    1. Rustのプロジェクトを作成する
    2. 必要なCコードを準備する
    3. CコードをRustにリンクする
    4. `build.rs`でビルド設定を追加する
    5. `Cargo.toml`の設定
    6. Rustコードに外部シンボルを定義する
  3. C言語でのグローバル変数の定義
    1. グローバル変数の基本的な定義
    2. グローバル変数の特徴
    3. 他のファイルからグローバル変数にアクセスする
    4. グローバル変数を使用する際の注意点
  4. RustからCのグローバル変数にアクセスする方法
    1. Cコードの準備
    2. Rustでの準備
    3. RustとCの連携
    4. 実行結果
    5. 注意点
  5. グローバル変数の安全な操作のためのRustの工夫
    1. 1. グローバル変数へのアクセスをラップする
    2. 2. マルチスレッド環境での競合防止
    3. 3. 型の互換性を確保する
    4. 4. `unsafe`コードの最小化
    5. 5. テストを活用する
    6. まとめ
  6. 具体的なコード例：CとRustの連携
    1. Cコードの準備
    2. Rustコードの準備
    3. `Cargo.toml`と`build.rs`の設定
    4. コードのビルドと実行
    5. 実行結果
    6. 重要なポイント
  7. 実践：C言語のグローバル変数をRustで書き換える
    1. Cコードの定義
    2. RustコードでCのグローバル変数を操作
    3. `Cargo.toml`と`build.rs`の設定
    4. コードのビルドと実行
    5. 実行結果
    6. 解説
    7. 応用例
  8. よくあるエラーとその対処法
    1. 1. シンボルの未定義エラー
    2. 2. メモリ安全性の問題
    3. 3. 型の不一致エラー
    4. 4. リンクエラー（ライブラリが見つからない）
    5. 5. グローバル変数の競合
    6. 6. デバッグが難しい問題
    7. まとめ
  9. まとめ