MENU
  1. ホーム
  2. Rust
  3. Rustのpubとデフォルト非公開アクセス指定子を徹底解説

Rustのpubとデフォルト非公開アクセス指定子を徹底解説

Rust

Rustは、その効率性と安全性から多くの開発者に選ばれるモダンなプログラミング言語です。その中でも、アクセス指定子は、データの隠蔽や安全性を高めるための重要な仕組みです。本記事では、Rustで使われるアクセス指定子の基本であるpub（公開）と、デフォルトで設定される非公開（private）の動作について解説します。これにより、モジュールやデータの設計時に適切な選択ができるようになります。Rustをより深く理解し、効率的に活用するための第一歩を学びましょう。

目次

Rustにおけるアクセス指定子の基本


アクセス指定子は、プログラム内のデータや関数の可視性を制御するために使用されます。Rustでは、デフォルトで非公開（private）が適用され、データや関数は同じモジュール内でのみアクセス可能です。一方で、pub指定子を使用することで、他のモジュールや外部コードからもアクセスできる公開状態にすることができます。

`pub`とデフォルト非公開の違い

  • デフォルト（非公開）：データや関数は宣言されたモジュール内でのみ使用可能です。他モジュールからは直接アクセスできません。
  • pub（公開）：明示的に公開指定を付与することで、他モジュールや外部クレートからもアクセス可能になります。

基本構文


以下は基本的な構文の例です。

mod my_module {
    pub struct PublicStruct {
        pub field: i32, // 公開
        private_field: i32, // 非公開
    }

    struct PrivateStruct {
        field: i32, // 非公開
    }

    pub fn public_function() {
        println!("This function is public");
    }

    fn private_function() {
        println!("This function is private");
    }
}
  • PublicStructはモジュール外部からアクセス可能ですが、PrivateStructは非公開です。
  • PublicStruct内のfieldは公開されており、外部からアクセス可能ですが、private_fieldは非公開です。

Rustのアクセス指定子はシンプルですが、データの安全性と適切なモジュール化をサポートする重要な役割を果たしています。この基本を理解することで、堅牢なコード設計が可能になります。

`pub`指定子の具体的な使用例


Rustのpub指定子は、モジュール外部からデータや関数にアクセス可能にするために使用されます。これにより、必要に応じて機能やデータを公開し、他のモジュールやクレートから再利用できるようになります。

公開関数の使用例


以下のコードは、pubを使用して公開された関数を示しています。

mod my_module {
    pub fn public_function() {
        println!("This is a public function.");
    }

    fn private_function() {
        println!("This is a private function.");
    }
}

fn main() {
    my_module::public_function(); // 呼び出し可能
    // my_module::private_function(); // エラー：非公開
}
  • public_functionはpub指定子によって公開されており、モジュール外部からアクセス可能です。
  • private_functionはデフォルトの非公開設定のため、モジュール外部からはアクセスできません。

公開構造体とフィールド


構造体全体を公開する場合はpubを使用しますが、内部のフィールドごとに公開・非公開を設定することも可能です。

mod my_module {
    pub struct PublicStruct {
        pub visible_field: i32,
        private_field: i32,
    }

    impl PublicStruct {
        pub fn new() -> PublicStruct {
            PublicStruct {
                visible_field: 42,
                private_field: 0,
            }
        }
    }
}

fn main() {
    let instance = my_module::PublicStruct::new();
    println!("{}", instance.visible_field); // アクセス可能
    // println!("{}", instance.private_field); // エラー：非公開
}
  • PublicStructはモジュール外部から利用可能ですが、private_fieldは非公開のためアクセスできません。
  • visible_fieldはpubによって公開されているため、外部からアクセス可能です。

モジュール階層における`pub`の利用


モジュールをまたいでデータや関数を公開する場合も、pubが必要です。

mod outer_module {
    pub mod inner_module {
        pub fn inner_function() {
            println!("This is a function in the inner module.");
        }
    }
}

fn main() {
    outer_module::inner_module::inner_function(); // 呼び出し可能
}

このように、pub指定子を使用することで、モジュールや構造体の設計に柔軟性を持たせながら、適切に機能を公開することができます。これにより、再利用性の高いコードを実現できます。

デフォルト非公開の動作と特徴


Rustでは、すべての項目（関数、構造体、モジュール、フィールドなど）がデフォルトで非公開（private）として扱われます。この非公開設定は、モジュールやクレート内でのデータの安全性を高め、不用意な外部アクセスを防ぐ役割を果たします。

デフォルト非公開の基本動作


非公開の項目は、宣言されたモジュール内でのみ使用可能で、外部のモジュールやクレートから直接アクセスすることはできません。

以下は非公開の動作を示す例です。

mod my_module {
    fn private_function() {
        println!("This is a private function.");
    }

    pub fn call_private_function() {
        private_function(); // 同じモジュール内から呼び出し可能
    }
}

fn main() {
    // my_module::private_function(); // エラー：非公開
    my_module::call_private_function(); // 呼び出し可能
}
  • private_functionは非公開のため、モジュール外部からは直接呼び出せません。
  • モジュール内部からは問題なく利用でき、call_private_functionを通じて間接的にアクセス可能です。

非公開の特徴

  1. 安全性の向上
    非公開設定により、モジュール外部からの不正アクセスや誤った操作を防ぎ、コードの安全性を高めます。
  2. カプセル化の促進
    非公開設定は、モジュールやクレート内でのカプセル化を助け、コードの可読性と保守性を向上させます。設計上公開が必要な部分だけを明示的に公開できます。
  3. 意図的な設計が可能
    開発者がpubを明示的に指定することで、意図的に必要な部分だけを公開し、API設計がより堅牢になります。

非公開の制限範囲


非公開設定の範囲は、モジュール階層によって異なります。

mod outer_module {
    mod inner_module {
        fn inner_function() {
            println!("This is an inner function.");
        }
    }

    pub fn call_inner_function() {
        // inner_module::inner_function(); // エラー：非公開
    }
}

fn main() {
    // outer_module::call_inner_function(); // エラー：非公開
}
  • inner_functionは、inner_module内でのみ使用可能です。
  • call_inner_functionも、outer_module外部からは使用できません。

非公開設定の有効活用


デフォルト非公開は、以下のような場合に特に有効です。

  • 内部実装の隠蔽：外部からの変更を防ぎ、内部実装を安全に保つ。
  • 明確なAPIの設計：意図的に公開範囲を指定することで、過剰な公開を防止。

Rustのデフォルト非公開設定は、適切なスコープ制御を可能にし、堅牢で安全なコード設計をサポートします。

モジュール構造とアクセス指定子の関係


Rustではモジュール（mod）を活用してプログラムを論理的に分割し、コードの管理を効率化します。このモジュール構造において、アクセス指定子は、どの範囲でデータや関数を利用できるかを制御する重要な役割を果たします。

モジュールの基本構造


Rustのモジュールは、コードを階層的に構造化するために使用されます。モジュール内で宣言された要素（関数、構造体、フィールドなど）は、デフォルトでそのモジュール内に限定されます。

mod outer_module {
    pub mod inner_module {
        pub fn public_function() {
            println!("This is a public function.");
        }

        fn private_function() {
            println!("This is a private function.");
        }
    }
}

fn main() {
    outer_module::inner_module::public_function(); // 呼び出し可能
    // outer_module::inner_module::private_function(); // エラー：非公開
}
  • inner_module::public_functionはpub指定されているため、モジュール外部からアクセス可能です。
  • inner_module::private_functionは非公開のため、外部からアクセスできません。

モジュール階層と`pub`の影響


アクセス指定子pubは、公開の範囲をモジュール階層に応じて制御します。

  1. モジュール間のアクセス
    pubを指定しない場合、データや関数は宣言されたモジュール内に限定されます。
  2. クレート外部への公開
    pubを付与することで、同一クレート内の他モジュールからアクセス可能になります。ただし、クレート外部に公開する場合にはpub(crate)または完全公開（pub）が必要です。
pub mod outer_module {
    pub fn public_function() {
        println!("Accessible from the crate and outside.");
    }

    pub(crate) fn crate_only_function() {
        println!("Accessible only within the crate.");
    }

    fn private_function() {
        println!("Accessible only within the module.");
    }
}
  • public_functionは完全公開され、クレート外部からも利用可能です。
  • crate_only_functionはクレート内でのみ利用可能です。
  • private_functionはouter_module内でのみ利用可能です。

モジュール設計におけるベストプラクティス

  1. APIとして公開する機能を限定する
    必要最小限の関数やデータのみをpub指定し、内部実装は非公開にすることでモジュールの安全性を高めます。
  2. モジュール間の明確な責任分担
    モジュールを設計するときは、それぞれの役割と責任を明確にし、アクセス指定子を利用してデータの流れを制御します。
  3. 複雑なモジュール構造ではpub(crate)を活用
    クレート内でのみ利用可能な要素を明示することで、コードの意図を明確にできます。

モジュール構造とアクセス指定子の実践例

pub mod library {
    pub mod parser {
        pub fn parse_data(input: &str) -> String {
            format!("Parsed: {}", input)
        }

        fn helper_function(data: &str) -> &str {
            data.trim()
        }
    }

    mod utilities {
        pub(crate) fn helper_util() {
            println!("This is a helper utility.");
        }
    }
}

fn main() {
    let result = library::parser::parse_data(" Example data ");
    println!("{}", result);
    // library::parser::helper_function(); // エラー：非公開
    // library::utilities::helper_util(); // エラー：crate内限定
}

このように、Rustのアクセス指定子を適切に利用することで、モジュール構造を整理し、意図的に設計された安全なコードを構築できます。

他モジュールからのデータアクセスの実現


Rustでは、モジュール間でデータや関数を共有する際にアクセス指定子を利用して制御します。他のモジュールからデータにアクセスするには、適切な範囲でpubやその他のアクセス修飾子を使用することが重要です。

モジュール外部からのデータ共有


以下は、モジュール外部からデータや関数を利用可能にする基本的な方法です。

mod module_a {
    pub struct PublicStruct {
        pub field: i32, // 公開フィールド
        private_field: i32, // 非公開フィールド
    }

    impl PublicStruct {
        pub fn new(value: i32) -> PublicStruct {
            PublicStruct {
                field: value,
                private_field: value * 2,
            }
        }

        pub fn get_private_field(&self) -> i32 {
            self.private_field
        }
    }
}

fn main() {
    let instance = module_a::PublicStruct::new(10);
    println!("Public field: {}", instance.field); // アクセス可能
    println!(
        "Private field: {}",
        instance.get_private_field() // 間接的にアクセス可能
    );
    // println!("{}", instance.private_field); // エラー：非公開
}
  • PublicStructのfieldはpubで公開されており、直接アクセス可能です。
  • private_fieldは非公開のため、外部から直接アクセスできませんが、メソッドget_private_fieldを通じて間接的に利用可能です。

モジュール間でのデータ共有


モジュール間でデータを共有する場合、適切にpub指定子を用いる必要があります。

mod module_a {
    pub struct SharedData {
        pub value: i32,
    }
}

mod module_b {
    pub fn display_data(data: &crate::module_a::SharedData) {
        println!("Shared value: {}", data.value);
    }
}

fn main() {
    let shared = module_a::SharedData { value: 42 };
    module_b::display_data(&shared);
}
  • SharedDataはpubで公開されているため、他のモジュールから参照可能です。
  • module_b::display_dataは、他モジュールからのデータ受け渡しを可能にする関数です。

モジュールを超えたアクセス制御


Rustでは、クレート全体やモジュール階層内でのアクセスを制御するためにpub(crate)やpub(super)といった修飾子を活用できます。

mod outer {
    pub(crate) fn crate_only_function() {
        println!("Accessible only within the crate.");
    }

    mod inner {
        pub(super) fn parent_accessible_function() {
            println!("Accessible by parent module.");
        }
    }

    pub fn call_inner_function() {
        inner::parent_accessible_function();
    }
}

fn main() {
    outer::crate_only_function(); // 呼び出し可能（クレート内）
    outer::call_inner_function(); // 呼び出し可能
}
  • pub(crate)でクレート内に限定した公開を行い、外部クレートからのアクセスを制限します。
  • pub(super)は親モジュールへの公開に使用されます。

モジュール間アクセスのベストプラクティス

  1. 必要最小限の公開
    本当に必要な項目だけを公開し、データの流出を防ぐ。
  2. アクセサメソッドの利用
    非公開フィールドやデータへのアクセスは、専用のアクセサメソッドを通じて行う。
  3. アクセス修飾子の活用
    pub(crate)やpub(super)を使って、過剰な公開を防ぎつつ、適切な範囲で共有する。

モジュール間のデータアクセスを適切に設計することで、Rustの安全性と可読性を維持しつつ、柔軟なコード設計を実現できます。

アクセス指定子と安全性のバランス


Rustのアクセス指定子は、データの安全性を高めつつ、柔軟性を持たせた設計を可能にします。しかし、必要以上にデータを公開すると安全性が損なわれるリスクがあります。このセクションでは、セキュリティと可読性の観点から適切な指定子の選択について解説します。

アクセス指定子が安全性に与える影響

  1. 非公開（private）の利点
  • データやロジックをモジュール内部に限定することで、不必要な外部アクセスを防ぎます。
  • 内部実装の変更が外部コードに影響を与えるリスクを軽減します。
  • バグや意図しない操作によるデータ破壊を防ぎます。
  1. pubの利点とリスク
  • 利点：必要な機能を他のモジュールや外部クレートから利用できるようにする。
  • リスク：過剰に公開すると、モジュール外部から不適切に操作される可能性がある。

安全性と柔軟性のバランスを取る方法

  1. 最小権限の原則を適用する
    必要最低限の項目のみ公開します。たとえば、内部データを直接公開する代わりに、アクセサメソッドを使用します。
pub struct Account {
    balance: i32, // 非公開
}

impl Account {
    pub fn new(initial_balance: i32) -> Account {
        Account {
            balance: initial_balance,
        }
    }

    pub fn get_balance(&self) -> i32 {
        self.balance
    }

    pub fn deposit(&mut self, amount: i32) {
        self.balance += amount;
    }
}
  • balanceは非公開に設定され、アクセサメソッドを通じて安全に操作します。
  1. モジュールごとに役割を限定する
    モジュールの責務を明確にし、外部からの操作を必要最小限に抑える。
mod api {
    pub fn perform_action() {
        println!("Action performed via API.");
    }
}

mod internal {
    pub(crate) fn helper_function() {
        println!("Helper function for internal use.");
    }
}
  • apiモジュールは外部アクセス用に設計され、internalモジュールは内部専用として機能します。

具体的なバランスの取り方

  • 単一クレート内の設計
  • クレート内部の共有が必要な場合はpub(crate)を使用。
  • 他モジュールから呼び出すべきではない項目は非公開に設定。
  • ライブラリクレートの場合
  • パブリックAPIは明確に設計し、内部実装の詳細は非公開にする。
  • ドキュメント化することで、利用者が適切に機能を使えるようにする。

アクセス指定子とセキュリティの実践例

mod secure {
    pub struct Auth {
        username: String,
        password: String,
    }

    impl Auth {
        pub fn new(username: &str, password: &str) -> Auth {
            Auth {
                username: username.to_string(),
                password: password.to_string(),
            }
        }

        pub fn authenticate(&self, input_password: &str) -> bool {
            self.password == input_password
        }
    }
}

fn main() {
    let auth = secure::Auth::new("user", "password123");
    if auth.authenticate("password123") {
        println!("Authentication successful!");
    } else {
        println!("Authentication failed.");
    }
}
  • パスワードフィールドを非公開にして、アクセサを通じた安全な認証を実現。

結論


アクセス指定子の適切な使用は、安全性を確保しつつ、コードの再利用性や拡張性を高めるために不可欠です。Rustの柔軟なアクセス制御機能を活用し、設計の目的に応じて安全性と柔軟性のバランスを取ることが、堅牢なプログラムを構築する鍵です。

演習問題：モジュールとアクセス指定子の練習


ここでは、Rustにおけるアクセス指定子の理解を深めるための演習問題を提供します。この演習を通じて、データの公開・非公開やモジュール間のアクセスの設定方法を実践的に学びます。

問題 1: モジュール間のデータ共有


次のコードを完成させて、main関数からmodule_aのデータにアクセスできるようにしてください。ただし、module_a内の非公開フィールドは直接アクセスできないようにしてください。

mod module_a {
    pub struct Data {
        pub visible_field: i32, // 公開フィールド
        hidden_field: i32,      // 非公開フィールド
    }

    impl Data {
        // 非公開フィールドにアクセスできる関数を作成してください
    }
}

fn main() {
    let data = module_a::Data {
        visible_field: 10,
        // hidden_field: 20, // 非公開なのでアクセス不可
    };
    // `hidden_field`の値を取得できる関数を使って値を表示してください
}

期待する出力：

Visible field: 10
Hidden field: 20

問題 2: モジュール構造と`pub(crate)`の利用


以下のコードでは、module_bがmodule_a内の非公開関数を呼び出そうとしています。このコードを修正して、module_bからmodule_aの関数を呼び出せるようにしてください。ただし、main関数からはその関数にアクセスできないようにしてください。

mod module_a {
    pub(crate) fn helper_function() {
        println!("Helper function called");
    }
}

mod module_b {
    pub fn call_helper() {
        // `module_a::helper_function`を呼び出してください
    }
}

fn main() {
    // module_a::helper_function(); // エラーにする
    module_b::call_helper(); // 呼び出し可能
}

期待する出力：

Helper function called

問題 3: フィールドのアクセス制御


次のコードでは、構造体Personのデータフィールドに適切なアクセス制御を追加してください。

mod person_module {
    pub struct Person {
        pub name: String,
        age: u8, // 非公開
    }

    impl Person {
        pub fn new(name: &str, age: u8) -> Person {
            Person {
                name: name.to_string(),
                age,
            }
        }

        // `age`を外部から取得するための関数を実装してください
    }
}

fn main() {
    let person = person_module::Person::new("Alice", 30);
    println!("Name: {}", person.name);
    // println!("Age: {}", person.age); // 非公開なのでアクセス不可
    // `age`を取得できる関数を使用してください
}

期待する出力：

Name: Alice
Age: 30

問題 4: モジュール間の関数公開


以下のコードで、module_cのperform_task関数がmodule_dを利用してタスクを実行するように変更してください。ただし、module_d::private_functionは非公開のままにしてください。

mod module_c {
    pub fn perform_task() {
        // `module_d::private_function`を呼び出してタスクを実行してください
    }
}

mod module_d {
    pub(crate) fn private_function() {
        println!("Task performed by private function.");
    }
}

fn main() {
    module_c::perform_task();
}

期待する出力：

Task performed by private function.

演習のポイント


これらの演習問題を通じて、以下のスキルを磨くことを目指します。

  1. pubと非公開の使い分け。
  2. モジュール内とモジュール間のデータ共有の適切な設計。
  3. pub(crate)やアクセサメソッドを活用した安全な設計。

コードを動かしながら試行錯誤することで、Rustのアクセス指定子の理解を深めましょう。

よくあるミスとトラブルシューティング


Rustのアクセス指定子を使用する際、初心者がよく陥るミスやトラブルを紹介し、それらを解決するための方法を解説します。これらの知識を活用することで、効率的かつ安全なコードを書くことができます。

1. 非公開要素へのアクセスを試みる


問題：非公開のデータや関数にアクセスしようとしてエラーが発生する。

mod my_module {
    fn private_function() {
        println!("This is a private function.");
    }
}

fn main() {
    // my_module::private_function(); // エラー：非公開
}

解決方法：
非公開要素はモジュール外からアクセスできないため、以下のいずれかを実行します。

  1. 必要ならばpubを付与して公開する。
  2. モジュール内で公開関数を作成し、その中で非公開要素を利用する。
mod my_module {
    fn private_function() {
        println!("This is a private function.");
    }

    pub fn public_function() {
        private_function();
    }
}

fn main() {
    my_module::public_function(); // 間接的に呼び出し可能
}

2. `pub(crate)`と`pub(super)`の誤用


問題：モジュール内で公開したつもりの関数やデータが、意図した範囲でアクセスできない。

mod outer {
    pub(crate) fn crate_only_function() {
        println!("Accessible only within the crate.");
    }
}

fn main() {
    outer::crate_only_function(); // クレート内ならOK
}
  • pub(crate)を使用した場合、クレート外部からアクセスしようとするとエラーになります。
  • pub(super)を使用した場合、親モジュールからのみアクセス可能です。

解決方法：
アクセス範囲を正確に理解し、設計意図に合った修飾子を使用します。完全に公開したい場合は、pubを使用します。

3. 構造体フィールドの非公開設定


問題：構造体を公開したが、フィールドが非公開であるため、外部で使用できない。

pub struct MyStruct {
    pub visible_field: i32,
    private_field: i32, // 非公開
}

fn main() {
    let instance = MyStruct {
        visible_field: 42,
        private_field: 0, // エラー：非公開
    };
}

解決方法：
フィールドを公開するか、アクセサメソッドを提供して間接的にアクセスできるようにします。

pub struct MyStruct {
    pub visible_field: i32,
    private_field: i32,
}

impl MyStruct {
    pub fn new(value: i32) -> MyStruct {
        MyStruct {
            visible_field: value,
            private_field: value * 2,
        }
    }

    pub fn get_private_field(&self) -> i32 {
        self.private_field
    }
}

4. モジュール階層のミス


問題：モジュールの構造を正しく記述していないために、予期せぬ非公開エラーが発生する。

mod module_a {
    pub mod module_b {
        pub fn public_function() {
            println!("Public function in module_b");
        }
    }
}

fn main() {
    // module_a::module_b::public_function(); // エラー：モジュール構造の間違い
}

解決方法：
モジュールの階層を正しく設計し、適切に公開することで問題を解消します。

mod module_a {
    pub mod module_b {
        pub fn public_function() {
            println!("Public function in module_b");
        }
    }
}

fn main() {
    module_a::module_b::public_function(); // 正常に呼び出し可能
}

5. 非公開関数をテストしたい


問題：非公開関数をテストモジュールから直接呼び出すことができない。

解決方法：
#[cfg(test)]属性でテストモジュールを定義し、モジュール内でテストを実施します。

mod my_module {
    fn private_function() -> i32 {
        42
    }

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

        #[test]
        fn test_private_function() {
            assert_eq!(private_function(), 42);
        }
    }
}

まとめ


Rustのアクセス指定子は、安全性を確保しつつ、柔軟な設計を可能にします。これらのトラブルシューティングを参考に、よくあるミスを回避し、効率的で安全なコードを作成してください。

まとめ


本記事では、Rustにおけるアクセス指定子の基本概念から具体的な使用方法、よくあるミスとその解決方法までを解説しました。デフォルト非公開やpub指定子の特性を理解し、適切に使い分けることで、安全で柔軟なモジュール設計が可能になります。これにより、堅牢なコードを構築し、Rustの持つ強力な機能を最大限に活用できるでしょう。Rustでのプログラミングの基礎をしっかりと学び、効率的な開発を目指してください。

Rust
プログラミング基礎 アクセス指定子 Rust

コメント

コメントする

目次