[C++] 多重継承におけるthisポインタについて解説

2025-04-15更新日: 2025-04-15

C++における多重継承では、クラスが複数の基底クラスを継承するため、各基底クラスのメンバ関数内でのthisポインタの扱いが重要です。

多重継承では、派生クラスのオブジェクトは基底クラスごとに異なる部分を持つため、thisポインタは基底クラスごとに異なるアドレスを指すことがあります。

特に仮想継承を使用する場合、基底クラスのインスタンスが共有されるため、thisポインタの調整が必要となり、コンパイラが内部的にポインタのオフセットを管理します。

目次から探す

多重継承におけるthisポインタの挙動
仮想継承とthisポインタの詳細
多重継承におけるthisポインタの応用例
まとめ

多重継承におけるthisポインタの挙動

C++における多重継承は、複数の基底クラスから派生クラスを作成することを可能にします。

この際、thisポインタの挙動は特に重要です。

thisポインタは、オブジェクト自身を指し示すポインタであり、多重継承においてはその挙動が複雑になります。

以下では、各側面について詳しく解説します。

多重継承時のメモリレイアウト

多重継承を使用すると、メモリレイアウトは基底クラスの数や種類によって異なります。

各基底クラスは、派生クラスのメモリ内にそれぞれのメンバを持ちます。

以下の表は、メモリレイアウトの基本的な構造を示しています。

基底クラス名	メモリサイズ	オフセット
Base1	8バイト	0
Base2	8バイト	8
Derived	8バイト	16

このように、各基底クラスのメンバは、派生クラスのメモリ内で連続して配置されます。

基底クラスごとのthisポインタ

多重継承において、各基底クラスは独自のthisポインタを持ちます。

これにより、基底クラスのメンバ関数を呼び出す際に、正しいオフセットを考慮する必要があります。

以下のサンプルコードは、基底クラスごとのthisポインタの挙動を示しています。

#include <iostream>
class Base1 {
public:
    void show() {
        std::cout << "Base1のメンバ関数" << std::endl;
    }
};
class Base2 {
public:
    void show() {
        std::cout << "Base2のメンバ関数" << std::endl;
    }
};
class Derived : public Base1, public Base2 {
public:
    void show() {
        Base1::show(); // Base1のthisポインタを使用
        Base2::show(); // Base2のthisポインタを使用
    }
};
int main() {
    Derived obj;
    obj.show();
    return 0;
}

Base1のメンバ関数
Base2のメンバ関数

このコードでは、DerivedクラスがBase1とBase2を継承し、それぞれのshowメンバ関数を呼び出しています。

各基底クラスのthisポインタが正しく機能していることがわかります。

派生クラスでのthisポインタの扱い

派生クラス内でのthisポインタは、派生クラスのオブジェクトを指しますが、基底クラスのメンバ関数を呼び出す際には、基底クラスのthisポインタを考慮する必要があります。

以下のサンプルコードは、派生クラスでのthisポインタの扱いを示しています。

#include <iostream>
class Base {
public:
    void show() {
        std::cout << "Baseのメンバ関数" << std::endl;
    }
};
class Derived : public Base {
public:
    void show() {
        std::cout << "Derivedのメンバ関数" << std::endl;
        Base::show(); // Baseのthisポインタを使用
    }
};
int main() {
    Derived obj;
    obj.show();
    return 0;
}

Derivedのメンバ関数
Baseのメンバ関数

このコードでは、Derivedクラスのshowメンバ関数がBaseクラスのshowメンバ関数を呼び出しています。

thisポインタは、正しい基底クラスのメンバ関数を指し示しています。

仮想継承とthisポインタの関係

仮想継承を使用すると、基底クラスのインスタンスが一つだけ作成され、thisポインタの扱いが変わります。

仮想継承を使用することで、ダイヤモンド継承の問題を回避できます。

以下のサンプルコードは、仮想継承におけるthisポインタの挙動を示しています。

#include <iostream>
class Base {
public:
    void show() {
        std::cout << "Baseのメンバ関数" << std::endl;
    }
};
class Derived1 : virtual public Base {
public:
    void show() {
        std::cout << "Derived1のメンバ関数" << std::endl;
        Base::show(); // Baseのthisポインタを使用
    }
};
class Derived2 : virtual public Base {
public:
    void show() {
        std::cout << "Derived2のメンバ関数" << std::endl;
        Base::show(); // Baseのthisポインタを使用
    }
};
class Final : public Derived1, public Derived2 {
public:
    void show() {
        std::cout << "Finalのメンバ関数" << std::endl;
        Derived1::show();
        Derived2::show();
    }
};
int main() {
    Final obj;
    obj.show();
    return 0;
}

Finalのメンバ関数
Derived1のメンバ関数
Baseのメンバ関数
Derived2のメンバ関数
Baseのメンバ関数

このコードでは、FinalクラスがDerived1とDerived2を継承し、両方のshowメンバ関数を呼び出しています。

仮想継承により、Baseクラスのインスタンスは一つだけ作成され、thisポインタが正しく機能しています。

オフセット調整とthisポインタ

多重継承において、thisポインタのオフセット調整が必要です。

基底クラスのメンバにアクセスする際、thisポインタは基底クラスのオフセットを考慮して調整されます。

以下のサンプルコードは、オフセット調整の例を示しています。

#include <iostream>
class Base1 {
public:
    int value1;
    Base1() : value1(1) {}
};
class Base2 {
public:
    int value2;
    Base2() : value2(2) {}
};
class Derived : public Base1, public Base2 {
public:
    void show() {
        std::cout << "value1: " << value1 << std::endl; // Base1のメンバ
        std::cout << "value2: " << value2 << std::endl; // Base2のメンバ
    }
};
int main() {
    Derived obj;
    obj.show();
    return 0;
}

value1: 1
value2: 2

このコードでは、DerivedクラスがBase1とBase2を継承し、それぞれのメンバにアクセスしています。

thisポインタは、基底クラスのオフセットを考慮して調整されているため、正しくメンバにアクセスできます。

仮想継承とthisポインタの詳細

仮想継承は、C++における多重継承の一形態であり、特にダイヤモンド継承の問題を解決するために使用されます。

仮想基底クラスを使用することで、基底クラスのインスタンスが一つだけ作成され、thisポインタの扱いが変わります。

以下では、仮想継承に関する詳細を解説します。

仮想継承の仕組み

仮想継承は、基底クラスを仮想基底クラスとして宣言することで実現されます。

これにより、派生クラスが同じ基底クラスを共有し、基底クラスのインスタンスが一つだけ作成されます。

以下のサンプルコードは、仮想継承の基本的な仕組みを示しています。

#include <iostream>
class Base {
public:
    void show() {
        std::cout << "Baseのメンバ関数" << std::endl;
    }
};
class Derived1 : virtual public Base {
public:
    void show() {
        std::cout << "Derived1のメンバ関数" << std::endl;
    }
};
class Derived2 : virtual public Base {
public:
    void show() {
        std::cout << "Derived2のメンバ関数" << std::endl;
    }
};
class Final : public Derived1, public Derived2 {
public:
    void show() {
        std::cout << "Finalのメンバ関数" << std::endl;
        Base::show(); // Baseのメンバ関数を呼び出す
    }
};
int main() {
    Final obj;
    obj.show();
    return 0;
}

Finalのメンバ関数
Baseのメンバ関数

このコードでは、FinalクラスがDerived1とDerived2を継承し、両方の派生クラスが同じBaseクラスを仮想基底クラスとして持っています。

これにより、Baseクラスのインスタンスは一つだけ作成されます。

仮想基底クラスのthisポインタ

仮想基底クラスのthisポインタは、派生クラスのオブジェクトを指し示しますが、基底クラスのメンバ関数を呼び出す際には、仮想基底クラスのオフセットを考慮する必要があります。

以下のサンプルコードは、仮想基底クラスのthisポインタの挙動を示しています。

#include <iostream>
class Base {
public:
    void show() {
        std::cout << "Baseのメンバ関数" << std::endl;
    }
};
class Derived1 : virtual public Base {
public:
    void show() {
        std::cout << "Derived1のメンバ関数" << std::endl;
        Base::show(); // Baseのthisポインタを使用
    }
};
class Derived2 : virtual public Base {
public:
    void show() {
        std::cout << "Derived2のメンバ関数" << std::endl;
        Base::show(); // Baseのthisポインタを使用
    }
};
class Final : public Derived1, public Derived2 {
public:
    void show() {
        std::cout << "Finalのメンバ関数" << std::endl;
        Derived1::show();
        Derived2::show();
    }
};
int main() {
    Final obj;
    obj.show();
    return 0;
}

Finalのメンバ関数
Derived1のメンバ関数
Baseのメンバ関数
Derived2のメンバ関数
Baseのメンバ関数

このコードでは、FinalクラスがDerived1とDerived2を継承し、両方のshowメンバ関数を呼び出しています。

仮想基底クラスのthisポインタが正しく機能していることがわかります。

仮想継承におけるメモリ効率

仮想継承を使用することで、メモリ効率が向上します。

通常の多重継承では、同じ基底クラスが複数回インスタンス化される可能性がありますが、仮想継承を使用することで、基底クラスのインスタンスは一つだけ作成されます。

以下の表は、仮想継承と通常の多重継承のメモリ効率の違いを示しています。

特徴	通常の多重継承	仮想継承
基底クラスのインスタンス数	複数回作成される	一つだけ作成される
メモリ使用量	増加する	削減される
アクセス速度	遅くなる可能性	高速になる

このように、仮想継承を使用することで、メモリの使用量を削減し、アクセス速度を向上させることができます。

仮想継承のthisポインタの調整

仮想継承においては、thisポインタの調整が必要です。

基底クラスのメンバにアクセスする際、thisポインタは仮想基底クラスのオフセットを考慮して調整されます。

以下のサンプルコードは、仮想継承におけるthisポインタの調整を示しています。

#include <iostream>
class Base {
public:
    int value;
    Base() : value(10) {}
};
class Derived1 : virtual public Base {
public:
    void show() {
        std::cout << "Derived1のvalue: " << value << std::endl; // Baseのメンバ
    }
};
class Derived2 : virtual public Base {
public:
    void show() {
        std::cout << "Derived2のvalue: " << value << std::endl; // Baseのメンバ
    }
};
class Final : public Derived1, public Derived2 {
public:
    void show() {
        std::cout << "Finalのvalue: " << value << std::endl; // Baseのメンバ
    }
};
int main() {
    Final obj;
    obj.show();
    return 0;
}

Finalのvalue: 10

このコードでは、FinalクラスがDerived1とDerived2を継承し、Baseクラスのメンバvalueにアクセスしています。

thisポインタは、仮想基底クラスのオフセットを考慮して調整されているため、正しくメンバにアクセスできます。

多重継承におけるthisポインタの応用例

多重継承におけるthisポインタの挙動は、さまざまなプログラミングシナリオで重要な役割を果たします。

以下では、具体的な応用例を通じて、thisポインタの使い方やその挙動について解説します。

複数の基底クラスのメンバ関数呼び出し

多重継承を使用することで、複数の基底クラスのメンバ関数を呼び出すことができます。

以下のサンプルコードは、DerivedクラスがBase1とBase2のメンバ関数を呼び出す例です。

#include <iostream>
class Base1 {
public:
    void show() {
        std::cout << "Base1のメンバ関数" << std::endl;
    }
};
class Base2 {
public:
    void show() {
        std::cout << "Base2のメンバ関数" << std::endl;
    }
};
class Derived : public Base1, public Base2 {
public:
    void show() {
        Base1::show(); // Base1のメンバ関数を呼び出す
        Base2::show(); // Base2のメンバ関数を呼び出す
    }
};
int main() {
    Derived obj;
    obj.show();
    return 0;
}

Base1のメンバ関数
Base2のメンバ関数

このコードでは、DerivedクラスがBase1とBase2のshowメンバ関数を呼び出しています。

thisポインタは、各基底クラスのメンバ関数を正しく指し示しています。

仮想関数とthisポインタの関係

仮想関数を使用することで、基底クラスのメンバ関数をオーバーライドし、派生クラスでのthisポインタの挙動を制御できます。

以下のサンプルコードは、仮想関数とthisポインタの関係を示しています。

#include <iostream>
class Base {
public:
    virtual void show() {
        std::cout << "Baseのメンバ関数" << std::endl;
    }
};
class Derived : public Base {
public:
    void show() override { // オーバーライド
        std::cout << "Derivedのメンバ関数" << std::endl;
    }
};
int main() {
    Base* ptr = new Derived(); // Base型のポインタがDerivedを指す
    ptr->show(); // Derivedのshowが呼ばれる
    delete ptr;
    return 0;
}

Derivedのメンバ関数

このコードでは、BaseクラスのポインタがDerivedクラスのオブジェクトを指し示し、仮想関数showが呼び出されると、Derivedクラスのshowメンバ関数が実行されます。

thisポインタは、正しい派生クラスのインスタンスを指し示しています。

ダイヤモンド継承でのthisポインタの挙動

ダイヤモンド継承は、同じ基底クラスを持つ複数の派生クラスからさらに派生する構造です。

この場合、thisポインタの挙動が特に重要になります。

以下のサンプルコードは、ダイヤモンド継承におけるthisポインタの挙動を示しています。

#include <iostream>
class Base {
public:
    void show() {
        std::cout << "Baseのメンバ関数" << std::endl;
    }
};
class Derived1 : public Base {
public:
    void show() {
        std::cout << "Derived1のメンバ関数" << std::endl;
    }
};
class Derived2 : public Base {
public:
    void show() {
        std::cout << "Derived2のメンバ関数" << std::endl;
    }
};
class Final : public Derived1, public Derived2 {
public:
    void show() {
        Derived1::show(); // Derived1のshowを呼び出す
        Derived2::show(); // Derived2のshowを呼び出す
        Base::show();     // Baseのshowを呼び出す
    }
};
int main() {
    Final obj;
    obj.show();
    return 0;
}

Derived1のメンバ関数
Derived2のメンバ関数
Baseのメンバ関数

このコードでは、FinalクラスがDerived1とDerived2を継承し、それぞれのshowメンバ関数を呼び出しています。

使用するコンパイラによってはBase::show();でコンパイルエラーになるため注意が必要です。

thisポインタは、各基底クラスのメンバ関数を正しく指し示しています。

複雑な継承構造でのthisポインタの管理

複雑な継承構造では、thisポインタの管理が重要です。

特に、複数の基底クラスを持つ場合、thisポインタのオフセットを考慮する必要があります。

以下のサンプルコードは、複雑な継承構造でのthisポインタの管理を示しています。

#include <iostream>
class Base1 {
public:
    void show() {
        std::cout << "Base1のメンバ関数" << std::endl;
    }
};
class Base2 {
public:
    void show() {
        std::cout << "Base2のメンバ関数" << std::endl;
    }
};
class Base3 {
public:
    void show() {
        std::cout << "Base3のメンバ関数" << std::endl;
    }
};
class Derived : public Base1, public Base2, public Base3 {
public:
    void show() {
        Base1::show(); // Base1のメンバ関数を呼び出す
        Base2::show(); // Base2のメンバ関数を呼び出す
        Base3::show(); // Base3のメンバ関数を呼び出す
    }
};
int main() {
    Derived obj;
    obj.show();
    return 0;
}

Base1のメンバ関数
Base2のメンバ関数
Base3のメンバ関数

このコードでは、DerivedクラスがBase1、Base2、Base3を継承し、それぞれのshowメンバ関数を呼び出しています。

thisポインタは、各基底クラスのメンバ関数を正しく指し示しており、複雑な継承構造でも適切に管理されています。

まとめ

この記事では、C++における多重継承とthisポインタの挙動について詳しく解説しました。

多重継承のメモリレイアウトや、基底クラスごとのthisポインタの扱い、仮想継承との関係、さらには複雑な継承構造でのthisポインタの管理方法についても触れました。

これらの知識を活用することで、C++の多重継承をより効果的に利用し、プログラムの設計や実装に役立てることができるでしょう。

今後は、実際のプロジェクトで多重継承を試し、thisポインタの挙動を観察することで、さらなる理解を深めてみてください。