C++アクセス指定子とオーバーライドの使い分け徹底解説：基本から応用まで

C++プログラミングにおいて、アクセス指定子（public、protected、private）とオーバーライドの使い分けは、コードの可読性や保守性に大きな影響を与えます。本記事では、アクセス指定子とオーバーライドの基礎から応用までを、具体的なコード例とともに分かりやすく解説します。

アクセス指定子の基礎

アクセス指定子は、C++のクラスメンバー（変数や関数）のアクセス権を制御するためのキーワードです。主にpublic、protected、privateの3つがあり、それぞれの役割は次の通りです。

public

public指定子は、そのクラスのメンバーがどこからでもアクセス可能であることを示します。クラス外部からも自由にアクセスできるため、インターフェース部分に用いることが多いです。

class MyClass {
public:
    int publicVar; // 公開メンバー変数
    void publicMethod(); // 公開メンバー関数
};

protected

protected指定子は、そのクラスおよび派生クラスからのみアクセス可能であることを示します。継承関係にあるクラス間でのアクセスを許可するため、内部の動作を共有する際に使用されます。

class BaseClass {
protected:
    int protectedVar; // 保護メンバー変数
    void protectedMethod(); // 保護メンバー関数
};

private

private指定子は、そのクラスのメンバーがクラス内部からのみアクセス可能であることを示します。外部や派生クラスからのアクセスを制限し、クラスの内部実装を隠蔽するために使用されます。

class MyClass {
private:
    int privateVar; // 非公開メンバー変数
    void privateMethod(); // 非公開メンバー関数
};

これらのアクセス指定子を適切に使い分けることで、クラスの設計をより効果的に行うことができます。

クラスとアクセス指定子の関係

アクセス指定子は、クラス設計において非常に重要な役割を果たします。これらの指定子を適切に使用することで、クラスのインターフェースと内部実装を明確に区別し、コードの可読性と保守性を向上させることができます。

インターフェースと実装の分離

クラスの公開インターフェースにはpublic指定子を用います。これにより、クラスを使用する他のコードからアクセス可能なメンバーが明確になります。一方、内部実装の詳細はprotectedまたはprivate指定子を用いて隠蔽します。

class MyClass {
public:
    void publicMethod(); // 公開インターフェース

protected:
    void protectedMethod(); // 内部実装の一部、派生クラスでも利用可能

private:
    int privateVar; // 内部実装の詳細、完全に隠蔽
};

カプセル化の実現

カプセル化とは、クラスの内部状態を隠蔽し、公開されたメソッドを通じてのみアクセス可能にする設計原則です。これにより、クラスの使用者は内部の実装に依存せず、安定したインターフェースを利用できます。

class BankAccount {
public:
    void deposit(double amount);
    void withdraw(double amount);
    double getBalance() const;

private:
    double balance; // 直接アクセス不可
};

継承におけるアクセス制御

継承関係において、protected指定子は特に重要です。派生クラスからアクセス可能なメンバーを指定することで、基底クラスの機能を再利用しつつ、必要な部分だけを拡張することができます。

class BaseClass {
protected:
    void baseMethod(); // 派生クラスからアクセス可能
};

class DerivedClass : public BaseClass {
public:
    void derivedMethod() {
        baseMethod(); // 基底クラスのメソッドを利用
    }
};

アクセス指定子を適切に使い分けることで、クラスの設計がより明確になり、他の開発者がコードを理解しやすくなります。

継承とアクセス指定子

継承においてアクセス指定子の使い方は、クラスの設計やコードの安全性に大きく影響します。アクセス指定子は、基底クラスのメンバーが派生クラスやクラス外からどのように見えるかを制御します。

public継承

public継承は、基底クラスのpublicメンバーを派生クラスでもpublicのまま公開し、protectedメンバーをprotectedのまま継承します。これにより、基底クラスのインターフェースがそのまま派生クラスに引き継がれます。

class BaseClass {
public:
    void publicMethod();
protected:
    void protectedMethod();
private:
    void privateMethod();
};

class DerivedClass : public BaseClass {
    // publicMethodはpublicのまま
    // protectedMethodはprotectedのまま
    // privateMethodはアクセス不可
};

protected継承

protected継承は、基底クラスのpublicおよびprotectedメンバーをprotectedとして継承します。これにより、派生クラスの外部からは基底クラスのメンバーにアクセスできなくなりますが、派生クラス内部やその派生クラスからはアクセス可能です。

class DerivedClass : protected BaseClass {
    // publicMethodはprotectedに
    // protectedMethodはprotectedのまま
    // privateMethodはアクセス不可
};

private継承

private継承は、基底クラスのpublicおよびprotectedメンバーをprivateとして継承します。派生クラスの外部からも、その内部からも基底クラスのメンバーにはアクセスできません。

class DerivedClass : private BaseClass {
    // publicMethodはprivateに
    // protectedMethodはprivateに
    // privateMethodはアクセス不可
};

アクセス指定子の影響

アクセス指定子の設定は、派生クラスが基底クラスのどのメンバーを利用できるかを決定します。これにより、クラス間の依存関係やアクセス範囲を制御し、コードの安全性とカプセル化を強化します。

class BaseClass {
public:
    void publicMethod() {
        // 公開メソッド
    }

protected:
    void protectedMethod() {
        // 保護メソッド
    }

private:
    void privateMethod() {
        // 非公開メソッド
    }
};

class DerivedClass : public BaseClass {
public:
    void testMethods() {
        publicMethod(); // アクセス可能
        protectedMethod(); // アクセス可能
        // privateMethod(); // アクセス不可
    }
};

アクセス指定子を適切に使うことで、クラスの設計がより安全かつ明確になり、意図しないアクセスや変更を防ぐことができます。

オーバーライドの基本

オーバーライド（Override）は、基底クラスで定義された仮想関数を派生クラスで再定義する機能です。これにより、基底クラスのポインタや参照を使って派生クラスのメソッドを呼び出すことが可能になります。

仮想関数の宣言

基底クラスで仮想関数を宣言するには、関数の前にvirtualキーワードを付けます。仮想関数は、派生クラスでオーバーライドされることを前提としています。

class BaseClass {
public:
    virtual void display() {
        std::cout << "BaseClass display" << std::endl;
    }
};

オーバーライドの実装

派生クラスで基底クラスの仮想関数をオーバーライドするには、関数の宣言を再定義し、overrideキーワードを付けます。これにより、意図的なオーバーライドであることを明示できます。

class DerivedClass : public BaseClass {
public:
    void display() override {
        std::cout << "DerivedClass display" << std::endl;
    }
};

仮想関数の呼び出し

基底クラスのポインタや参照を使って仮想関数を呼び出すと、実行時のオブジェクトの型に応じて、対応する派生クラスのメソッドが呼び出されます。これを「動的ポリモーフィズム」といいます。

void showDisplay(BaseClass& obj) {
    obj.display();
}

int main() {
    BaseClass base;
    DerivedClass derived;

    showDisplay(base);     // 出力: BaseClass display
    showDisplay(derived);  // 出力: DerivedClass display

    return 0;
}

オーバーライドのルール

オーバーライドする際には、以下のルールに従う必要があります。

関数のシグネチャ（名前、引数の型と数）が基底クラスと一致すること。
関数の戻り値の型が基底クラスの関数と互換性があること（共変戻り値型）。
アクセス指定子が同じか、より緩やかなものであること。

class AnotherDerived : public BaseClass {
public:
    int display() override { // 戻り値の型が異なるためエラー
        std::cout << "AnotherDerived display" << std::endl;
        return 0;
    }
};

オーバーライドは、C++の強力な機能であり、クラスの柔軟性と拡張性を高めるために不可欠です。基底クラスの仮想関数を適切にオーバーライドすることで、動的ポリモーフィズムを実現し、洗練されたオブジェクト指向設計を可能にします。

オーバーライドの実装方法

C++におけるオーバーライドの実装は、基底クラスの仮想関数を派生クラスで再定義することで行います。オーバーライドを正しく行うためには、いくつかの重要なポイントと注意点があります。

仮想関数の宣言とオーバーライド

まず、基底クラスで仮想関数を宣言し、それを派生クラスでオーバーライドします。派生クラスで再定義する関数にはoverrideキーワードを付けると、意図的なオーバーライドであることを明示できます。

class BaseClass {
public:
    virtual void showMessage() {
        std::cout << "Message from BaseClass" << std::endl;
    }
};

class DerivedClass : public BaseClass {
public:
    void showMessage() override {
        std::cout << "Message from DerivedClass" << std::endl;
    }
};

基底クラスのポインタとオーバーライド

基底クラスのポインタを使って派生クラスのオーバーライドされたメソッドを呼び出すことで、動的ポリモーフィズムを実現します。これは、実行時にオブジェクトの実際の型に基づいてメソッドが呼び出されることを意味します。

void displayMessage(BaseClass* obj) {
    obj->showMessage();
}

int main() {
    BaseClass base;
    DerivedClass derived;

    displayMessage(&base);    // 出力: Message from BaseClass
    displayMessage(&derived); // 出力: Message from DerivedClass

    return 0;
}

共変戻り値型

オーバーライドの際、基底クラスの仮想関数の戻り値型を派生クラスで変更することができます。ただし、新しい戻り値型は基底クラスの戻り値型の派生型でなければなりません。

class Base {
public:
    virtual Base* clone() {
        return new Base(*this);
    }
};

class Derived : public Base {
public:
    Derived* clone() override {
        return new Derived(*this);
    }
};

アクセス指定子とオーバーライド

オーバーライドする関数のアクセス指定子は、基底クラスの関数と同じか、より緩やかである必要があります。例えば、基底クラスの関数がprotectedである場合、派生クラスではprotectedまたはpublicにできますが、privateにすることはできません。

class BaseClass {
protected:
    virtual void protectedMethod() {
        std::cout << "BaseClass protected method" << std::endl;
    }
};

class DerivedClass : public BaseClass {
public:
    void protectedMethod() override {
        std::cout << "DerivedClass protected method" << std::endl;
    }
};

オーバーライドの注意点

オーバーライドを行う際には、関数のシグネチャが一致することが重要です。これには、関数名、引数の型と数、const修飾子の有無などが含まれます。シグネチャが一致しないと、意図したオーバーライドが行われず、新しいメソッドとして扱われることになります。

class BaseClass {
public:
    virtual void exampleMethod(int x) const {
        std::cout << "BaseClass method" << std::endl;
    }
};

class DerivedClass : public BaseClass {
public:
    void exampleMethod(int x) const override {
        std::cout << "DerivedClass method" << std::endl;
    }
};

オーバーライドを正しく実装することで、C++の動的ポリモーフィズムを活用し、柔軟で拡張性の高いコードを書くことができます。

オーバーライドとアクセス指定子の組み合わせ

オーバーライドとアクセス指定子を組み合わせることで、クラスの設計に柔軟性と安全性を加えることができます。ここでは、それぞれの組み合わせについて詳しく解説します。

publicメンバーとオーバーライド

publicメンバー関数をオーバーライドする場合、派生クラスでもそのメンバー関数はpublicのまま継承されます。これは、派生クラスのインターフェースを基底クラスと一致させるために重要です。

class BaseClass {
public:
    virtual void publicMethod() {
        std::cout << "BaseClass public method" << std::endl;
    }
};

class DerivedClass : public BaseClass {
public:
    void publicMethod() override {
        std::cout << "DerivedClass public method" << std::endl;
    }
};

protectedメンバーとオーバーライド

protectedメンバー関数をオーバーライドする場合、派生クラスでもそのメンバー関数はprotectedのままです。これにより、基底クラスと派生クラス間で共有されるが、クラス外部からはアクセスできないメソッドを定義できます。

class BaseClass {
protected:
    virtual void protectedMethod() {
        std::cout << "BaseClass protected method" << std::endl;
    }
};

class DerivedClass : public BaseClass {
protected:
    void protectedMethod() override {
        std::cout << "DerivedClass protected method" << std::endl;
    }
};

privateメンバーとオーバーライド

privateメンバー関数は、基底クラスで宣言されている限り、派生クラスでオーバーライドすることはできません。privateメンバー関数は、そのクラス内でのみアクセス可能であり、派生クラスからも見えないためです。

class BaseClass {
private:
    virtual void privateMethod() {
        std::cout << "BaseClass private method" << std::endl;
    }
};

class DerivedClass : public BaseClass {
    // void privateMethod() override { // エラー：privateメソッドはオーバーライドできない
    //    std::cout << "DerivedClass private method" << std::endl;
    // }
};

publicからprotectedへのオーバーライド

基底クラスでpublicメンバー関数として宣言されていても、派生クラスでprotectedとしてオーバーライドすることが可能です。これにより、派生クラスではそのメソッドを隠蔽し、外部からのアクセスを防ぐことができます。

class BaseClass {
public:
    virtual void publicMethod() {
        std::cout << "BaseClass public method" << std::endl;
    }
};

class DerivedClass : public BaseClass {
protected:
    void publicMethod() override {
        std::cout << "DerivedClass protected method" << std::endl;
    }
};

protectedからpublicへのオーバーライド

逆に、基底クラスでprotectedメンバー関数として宣言されているものを、派生クラスでpublicとしてオーバーライドすることも可能です。これにより、派生クラスでそのメソッドを公開し、外部からもアクセスできるようにします。

class BaseClass {
protected:
    virtual void protectedMethod() {
        std::cout << "BaseClass protected method" << std::endl;
    }
};

class DerivedClass : public BaseClass {
public:
    void protectedMethod() override {
        std::cout << "DerivedClass public method" << std::endl;
    }
};

アクセス指定子とオーバーライドの組み合わせを適切に使い分けることで、クラスの設計における柔軟性と安全性を高めることができます。これにより、意図しないアクセスや変更を防ぎつつ、必要な機能を適切に公開することができます。

アクセス指定子とオーバーライドの具体例

ここでは、アクセス指定子とオーバーライドを組み合わせた具体的なコード例を示します。これにより、これらの概念がどのように機能するかを実際に確認できます。

基底クラスの定義

まず、基底クラスを定義します。このクラスには、public、protected、privateのメンバー関数が含まれています。

#include <iostream>

class BaseClass {
public:
    virtual void publicMethod() {
        std::cout << "BaseClass public method" << std::endl;
    }

protected:
    virtual void protectedMethod() {
        std::cout << "BaseClass protected method" << std::endl;
    }

private:
    virtual void privateMethod() {
        std::cout << "BaseClass private method" << std::endl;
    }

public:
    void callPrivateMethod() {
        privateMethod(); // クラス内部からは呼び出せる
    }
};

派生クラスの定義

次に、基底クラスを継承する派生クラスを定義します。派生クラスでは、基底クラスのpublicおよびprotectedメンバー関数をオーバーライドしますが、privateメンバー関数はオーバーライドできません。

class DerivedClass : public BaseClass {
public:
    void publicMethod() override {
        std::cout << "DerivedClass public method" << std::endl;
    }

protected:
    void protectedMethod() override {
        std::cout << "DerivedClass protected method" << std::endl;
    }

    // privateMethodはオーバーライドできない
};

動的ポリモーフィズムの例

基底クラスのポインタを使って派生クラスのオーバーライドされたメソッドを呼び出す例を示します。これにより、動的ポリモーフィズムが実現されます。

int main() {
    BaseClass* basePtr;
    DerivedClass derivedObj;

    basePtr = &derivedObj;

    basePtr->publicMethod(); // 出力: DerivedClass public method
    basePtr->callPrivateMethod(); // 出力: BaseClass private method

    // basePtr->protectedMethod(); // エラー: protectedメソッドにはアクセス不可

    return 0;
}

アクセス指定子の変更

基底クラスのpublicメンバー関数を派生クラスでprotectedとしてオーバーライドし、アクセス範囲を変更する例を示します。

class AnotherDerivedClass : public BaseClass {
protected:
    void publicMethod() override {
        std::cout << "AnotherDerivedClass protected method" << std::endl;
    }
};

int main() {
    AnotherDerivedClass anotherDerived;
    anotherDerived.callPrivateMethod(); // 出力: BaseClass private method

    // anotherDerived.publicMethod(); // エラー: protectedメソッドにはアクセス不可

    return 0;
}

この例では、基底クラスのpublicメソッドが派生クラスでprotectedに変更されており、派生クラスのインスタンスから直接呼び出すことができなくなっています。

これらの具体例を通じて、アクセス指定子とオーバーライドの使い方がどのようにコードに影響するかを理解できるでしょう。適切に組み合わせることで、クラスの設計をより柔軟かつ安全に行うことができます。

応用例：アクセス指定子とオーバーライド

ここでは、実際のプロジェクトでアクセス指定子とオーバーライドを応用する例を紹介します。これにより、実践的な使い方を理解し、クラス設計における重要なポイントを押さえることができます。

ファイルシステムクラスの設計

ファイルシステムを管理するクラスを設計します。この例では、ファイルとディレクトリの基本操作を行うための基底クラスFileSystemItemと、それを継承するFileおよびDirectoryクラスを定義します。

#include <iostream>
#include <string>

class FileSystemItem {
public:
    FileSystemItem(const std::string& name) : name(name) {}
    virtual ~FileSystemItem() {}

    virtual void displayInfo() const {
        std::cout << "Item: " << name << std::endl;
    }

protected:
    std::string name;
};

class File : public FileSystemItem {
public:
    File(const std::string& name, size_t size) : FileSystemItem(name), size(size) {}

    void displayInfo() const override {
        std::cout << "File: " << name << " (" << size << " bytes)" << std::endl;
    }

private:
    size_t size;
};

class Directory : public FileSystemItem {
public:
    Directory(const std::string& name) : FileSystemItem(name) {}

    void displayInfo() const override {
        std::cout << "Directory: " << name << std::endl;
    }
};

動的ポリモーフィズムを用いた操作

基底クラスのポインタを使ってファイルとディレクトリを操作する例です。動的ポリモーフィズムを利用することで、実行時に正しいメソッドが呼び出されます。

void showItemInfo(const FileSystemItem& item) {
    item.displayInfo();
}

int main() {
    File myFile("example.txt", 1024);
    Directory myDir("example_folder");

    showItemInfo(myFile);  // 出力: File: example.txt (1024 bytes)
    showItemInfo(myDir);   // 出力: Directory: example_folder

    return 0;
}

アクセス指定子と安全な設計

クラス内のデータを安全に保つために、アクセス指定子を適切に使います。例えば、ファイルのサイズを直接変更できないようにするには、サイズの変更メソッドをprotectedまたはprivateにします。

class File : public FileSystemItem {
public:
    File(const std::string& name, size_t size) : FileSystemItem(name), size(size) {}

    void displayInfo() const override {
        std::cout << "File: " << name << " (" << size << " bytes)" << std::endl;
    }

protected:
    void setSize(size_t newSize) {
        size = newSize;
    }

private:
    size_t size;
};

この例では、setSizeメソッドがprotectedになっているため、派生クラスからアクセス可能ですが、外部からはアクセスできません。

派生クラスでの機能拡張

ディレクトリクラスにファイルやサブディレクトリを追加する機能を追加します。派生クラスで新たなメソッドを定義し、基底クラスの機能を拡張します。

#include <vector>
#include <memory>

class Directory : public FileSystemItem {
public:
    Directory(const std::string& name) : FileSystemItem(name) {}

    void displayInfo() const override {
        std::cout << "Directory: " << name << " (contains " << items.size() << " items)" << std::endl;
    }

    void addItem(std::shared_ptr<FileSystemItem> item) {
        items.push_back(item);
    }

private:
    std::vector<std::shared_ptr<FileSystemItem>> items;
};

int main() {
    auto root = std::make_shared<Directory>("root");
    auto file1 = std::make_shared<File>("file1.txt", 500);
    auto file2 = std::make_shared<File>("file2.txt", 1500);

    root->addItem(file1);
    root->addItem(file2);

    root->displayInfo();  // 出力: Directory: root (contains 2 items)

    return 0;
}

この例では、Directoryクラスにファイルやサブディレクトリを追加する機能を追加し、displayInfoメソッドをオーバーライドして、ディレクトリ内のアイテム数を表示します。

アクセス指定子とオーバーライドを効果的に使用することで、クラスの設計をより柔軟かつ安全に行うことができ、実践的なプロジェクトでの応用力を高めることができます。

演習問題

以下の演習問題を通じて、アクセス指定子とオーバーライドの理解を深めましょう。各問題には、説明とヒントも含まれています。

問題1: 基本的なアクセス指定子の使用

以下のクラスPersonを定義し、適切なアクセス指定子を使って名前と年齢を管理するようにしてください。

class Person {
public:
    // コンストラクタ
    Person(const std::string& name, int age);

    // 名前を取得するメソッド
    std::string getName() const;

    // 年齢を取得するメソッド
    int getAge() const;

private:
    // メンバー変数
    std::string name;
    int age;
};

問題2: オーバーライドの実装

基底クラスShapeを定義し、派生クラスCircleとRectangleを実装して、各クラスのdrawメソッドをオーバーライドしてください。

class Shape {
public:
    virtual void draw() const {
        std::cout << "Drawing a shape" << std::endl;
    }
};

class Circle : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing a circle" << std::endl;
    }
};

class Rectangle : public Shape {
public:
    void draw() const override {
        std::cout << "Drawing a rectangle" << std::endl;
    }
};

問題3: 継承とアクセス指定子の組み合わせ

以下のコードを完成させ、基底クラスAnimalを継承する派生クラスDogとCatを実装してください。各クラスには適切なアクセス指定子を使用し、makeSoundメソッドをオーバーライドしてください。

class Animal {
public:
    virtual void makeSound() const {
        std::cout << "Some generic animal sound" << std::endl;
    }
};

class Dog : public Animal {
public:
    void makeSound() const override {
        std::cout << "Bark" << std::endl;
    }
};

class Cat : public Animal {
public:
    void makeSound() const override {
        std::cout << "Meow" << std::endl;
    }
};

問題4: アクセス指定子の変更

基底クラスBaseのpublicメソッドをprotectedメソッドとしてオーバーライドし、派生クラスDerivedを実装してください。

class Base {
public:
    virtual void publicMethod() {
        std::cout << "Base public method" << std::endl;
    }
};

class Derived : public Base {
protected:
    void publicMethod() override {
        std::cout << "Derived protected method" << std::endl;
    }
};

問題5: 演習の応用

以下のクラスVehicleとその派生クラスCar、Bicycleを定義し、各クラスにmoveメソッドを追加してください。Vehicleクラスのmoveメソッドを仮想関数として宣言し、派生クラスでオーバーライドします。

class Vehicle {
public:
    virtual void move() const {
        std::cout << "Vehicle is moving" << std::endl;
    }
};

class Car : public Vehicle {
public:
    void move() const override {
        std::cout << "Car is driving" << std::endl;
    }
};

class Bicycle : public Vehicle {
public:
    void move() const override {
        std::cout << "Bicycle is pedaling" << std::endl;
    }
};

これらの演習問題を通じて、アクセス指定子とオーバーライドの基本的な使い方から、応用的な設計までを練習し、理解を深めてください。各問題に対する正解を確認しながら、実際にコードを実装してみましょう。

まとめ

本記事では、C++のアクセス指定子（public、protected、private）とオーバーライドについて、基本から応用までを解説しました。アクセス指定子を適切に使い分けることで、クラスのインターフェースと内部実装を明確に区別し、コードの安全性と可読性を向上させることができます。また、オーバーライドを利用することで、動的ポリモーフィズムを実現し、柔軟で拡張性の高いクラス設計が可能になります。演習問題を通じて実践的な理解を深め、今後のプログラミングに役立ててください。