MENU
  1. ホーム
  2. C++
  3. C++の型消去と動的ディスパッチの最適化手法

C++の型消去と動的ディスパッチの最適化手法

C++

C++におけるプログラムの性能と柔軟性を高めるためには、型消去と動的ディスパッチの技術が非常に重要です。型消去は、プログラムの抽象化と汎用性を向上させる手法であり、異なる型を同一のインターフェースで扱うことを可能にします。一方、動的ディスパッチは、実行時に適切な関数やメソッドを選択するメカニズムであり、オブジェクト指向プログラミングにおける多態性を実現します。これらの技術を理解し、効果的に最適化することで、高性能かつ柔軟なC++プログラムの構築が可能となります。本記事では、型消去と動的ディスパッチの基本概念から、具体的な実装方法、最適化技法、デバッグのポイントまでを詳細に解説します。

目次

型消去の基本概念

型消去（Type Erasure）は、C++において異なる型を共通のインターフェースで扱うための手法です。これは、テンプレートを使用して型を抽象化し、ランタイムで特定の型情報を保持しないようにすることを意味します。

型消去のメカニズム

型消去は、主にテンプレートと仮想関数を組み合わせて実装されます。テンプレートを使用して異なる型のオブジェクトを受け取り、その型情報を隠蔽します。これにより、統一されたインターフェースで異なる型のオブジェクトを操作できます。

型消去の利点

型消去には以下の利点があります：

  • コードの汎用性向上：異なる型を同じインターフェースで扱えるため、コードの再利用性が高まります。
  • コンパイル時の型安全性：テンプレートを使用するため、コンパイル時に型チェックが行われ、型安全性が保証されます。
  • 柔軟性：ランタイムに依存しないため、実行時のパフォーマンスが向上します。

型消去を理解することで、C++プログラムの抽象化と柔軟性を高めることができ、より汎用的で保守性の高いコードを書くことが可能になります。

動的ディスパッチの基本概念

動的ディスパッチ（Dynamic Dispatch）は、実行時に適切な関数やメソッドを選択して呼び出すメカニズムです。これは、オブジェクト指向プログラミングにおいて多態性（ポリモーフィズム）を実現するために重要な技術です。

動的ディスパッチの仕組み

動的ディスパッチは、主に仮想関数（virtual functions）を利用して実現されます。基底クラスに仮想関数を定義し、派生クラスでその関数をオーバーライドすることで、オブジェクトの実際の型に応じた関数が呼び出されます。このメカニズムにより、同じインターフェースで異なる具体的な実装を持つオブジェクトを扱うことができます。

動的ディスパッチの重要性

動的ディスパッチの主な利点は以下の通りです：

  • 多態性の実現：同じインターフェースで異なる型のオブジェクトを扱うことができるため、コードの柔軟性と拡張性が向上します。
  • コードの再利用性向上：共通のインターフェースを使用することで、異なるオブジェクトの操作を統一し、コードの再利用性が高まります。
  • メンテナンス性の向上：新しいクラスやメソッドを追加する際に、既存のコードを変更せずに機能を拡張できるため、メンテナンスが容易になります。

動的ディスパッチを活用することで、C++プログラムはより柔軟で拡張性の高い設計が可能となり、オブジェクト指向の利点を最大限に活かすことができます。

型消去と動的ディスパッチの関係

型消去と動的ディスパッチは、C++における抽象化と柔軟性を向上させるための重要な技術ですが、それぞれ異なる方法で実現されます。このセクションでは、これら二つの概念がどのように関連し、相互に作用するかについて説明します。

共通点

  • 抽象化の実現：どちらの技術も異なる型を共通のインターフェースで扱うための手段として機能します。型消去はテンプレートを使用し、動的ディスパッチは仮想関数を利用します。
  • 柔軟性の向上：異なる型やオブジェクトを統一的に扱うことで、コードの柔軟性と再利用性が向上します。

相違点

  • 実行時オーバーヘッド：動的ディスパッチは実行時に関数ポインタを解決するため、ランタイムオーバーヘッドが発生します。一方、型消去はコンパイル時に型が決定されるため、ランタイムオーバーヘッドが少なくなります。
  • 使用場面：型消去は、テンプレートメタプログラミングやSTL（標準テンプレートライブラリ）でよく使用されます。動的ディスパッチは、オブジェクト指向プログラミングや設計パターンで多用されます。

組み合わせの利点

型消去と動的ディスパッチを組み合わせることで、それぞれの利点を最大限に活用できます。例えば、テンプレートを用いた汎用的なインターフェースに仮想関数を組み合わせることで、異なる型のオブジェクトを動的に処理しつつ、高いパフォーマンスを維持できます。

型消去と動的ディスパッチの関係を理解し、適切に使い分けることで、C++プログラムの設計と実装が大幅に改善され、効率的で柔軟なコードを書くことが可能になります。

型消去の実装方法

型消去を使用することで、異なる型を共通のインターフェースで扱うことができます。このセクションでは、C++での型消去の具体的な実装方法とそのコード例を紹介します。

テンプレートを用いた型消去

型消去は、主にテンプレートと抽象基底クラスを用いて実装されます。テンプレートを使用して型を抽象化し、抽象基底クラスを介して共通のインターフェースを提供します。

例：Anyクラス

以下に、std::anyと同様の機能を持つ簡単なAnyクラスの実装例を示します。このクラスは、任意の型のオブジェクトを保持し、その型を消去します。

#include <iostream>
#include <memory>
#include <typeinfo>

// 抽象基底クラス
class AnyBase {
public:
    virtual ~AnyBase() = default;
    virtual const std::type_info& type() const = 0;
};

// 任意の型を保持するテンプレートクラス
template<typename T>
class AnyDerived : public AnyBase {
public:
    AnyDerived(T value) : value_(value) {}
    const std::type_info& type() const override { return typeid(T); }
    T value_;
};

// 型消去を実現するAnyクラス
class Any {
public:
    template<typename T>
    Any(T value) : ptr_(std::make_unique<AnyDerived<T>>(value)) {}

    const std::type_info& type() const { return ptr_->type(); }

    template<typename T>
    T& any_cast() {
        if (type() != typeid(T)) {
            throw std::bad_cast();
        }
        return static_cast<AnyDerived<T>*>(ptr_.get())->value_;
    }

private:
    std::unique_ptr<AnyBase> ptr_;
};

int main() {
    Any a = 10;
    std::cout << "Type: " << a.type().name() << ", Value: " << a.any_cast<int>() << std::endl;

    a = std::string("Hello, World!");
    std::cout << "Type: " << a.type().name() << ", Value: " << a.any_cast<std::string>() << std::endl;

    return 0;
}

型消去のポイント

  • 抽象基底クラス：すべての型に共通のインターフェースを提供するために使用します。
  • テンプレートクラス：具体的な型を保持し、抽象基底クラスのインターフェースを実装します。
  • ユニークポインタ：型消去されたオブジェクトを動的に管理し、メモリ管理を簡素化します。

このように、型消去を利用することで、異なる型のオブジェクトを共通のインターフェースで扱うことができ、コードの汎用性と柔軟性が向上します。

動的ディスパッチの実装方法

動的ディスパッチは、実行時に適切な関数やメソッドを選択するための技術です。これは、主に仮想関数を用いて実現されます。このセクションでは、動的ディスパッチを実装する具体的方法とそのコード例を紹介します。

仮想関数を用いた動的ディスパッチ

動的ディスパッチは、基底クラスに仮想関数を定義し、派生クラスでその関数をオーバーライドすることで実現されます。これにより、基底クラスのポインタまたは参照を通じて派生クラスのメソッドを呼び出すことができます。

例：動物クラス階層

以下に、動的ディスパッチを用いた簡単な動物クラスの実装例を示します。この例では、Animal基底クラスに仮想関数makeSoundを定義し、派生クラスDogとCatでそれぞれの具体的な実装を行います。

#include <iostream>
#include <memory>
#include <vector>

// 基底クラス
class Animal {
public:
    virtual ~Animal() = default;
    virtual void makeSound() const = 0; // 仮想関数
};

// 派生クラス Dog
class Dog : public Animal {
public:
    void makeSound() const override {
        std::cout << "Woof!" << std::endl;
    }
};

// 派生クラス Cat
class Cat : public Animal {
public:
    void makeSound() const override {
        std::cout << "Meow!" << std::endl;
    }
};

int main() {
    std::vector<std::unique_ptr<Animal>> animals;
    animals.push_back(std::make_unique<Dog>());
    animals.push_back(std::make_unique<Cat>());

    for (const auto& animal : animals) {
        animal->makeSound(); // 動的ディスパッチ
    }

    return 0;
}

動的ディスパッチのポイント

  • 仮想関数：基底クラスに仮想関数を定義し、動的ディスパッチを実現します。
  • オーバーライド：派生クラスで基底クラスの仮想関数をオーバーライドし、具体的な動作を定義します。
  • 基底クラスのポインタまたは参照：基底クラスのポインタまたは参照を使用して、派生クラスのメソッドを呼び出します。

動的ディスパッチを利用することで、オブジェクト指向プログラミングの多態性を実現し、コードの柔軟性と拡張性を向上させることができます。これにより、新しいクラスやメソッドを追加する際に既存のコードを変更せずに機能を拡張できるため、メンテナンスが容易になります。

型消去と動的ディスパッチの最適化技法

型消去と動的ディスパッチのパフォーマンスを最大化するためには、いくつかの最適化技法を適用することが重要です。このセクションでは、これらの技術を最適化するための具体的な手法について説明します。

型消去の最適化技法

型消去の最適化には、以下の手法が効果的です：

小さなオブジェクトの最適化（SBO）

小さなオブジェクトの最適化（Small Buffer Optimization, SBO）は、小さなオブジェクトを動的メモリではなくスタック上に格納することで、メモリ割り当てと解放のオーバーヘッドを削減します。これにより、性能が向上します。

template<size_t BufferSize>
class SmallAny {
public:
    template<typename T>
    SmallAny(T value) {
        static_assert(sizeof(T) <= BufferSize, "Type too large for SmallAny buffer");
        new (&buffer) T(value);
        type_info = &typeid(T);
    }

    const std::type_info& type() const { return *type_info; }

private:
    alignas(BufferSize) char buffer[BufferSize];
    const std::type_info* type_info;
};

型のインプレース構築

型のインプレース構築（In-place Construction）を利用することで、オブジェクトを直接目的のメモリ位置に構築し、不要なコピーを回避します。

template<typename T, typename... Args>
void construct_in_place(void* buffer, Args&&... args) {
    new (buffer) T(std::forward<Args>(args)...);
}

動的ディスパッチの最適化技法

動的ディスパッチの最適化には、以下の手法が有効です：

仮想関数テーブルのインライン化

仮想関数の呼び出しを減らすために、可能な限り関数をインライン化します。これはコンパイラの最適化オプション（例：-O2や-O3）を利用して実現できます。

class Base {
public:
    virtual void foo() const {
        // インライン化が可能な単純な関数
    }
};

class Derived : public Base {
public:
    void foo() const override {
        // インライン化が可能な単純な関数
    }
};

静的ディスパッチの利用

テンプレートメタプログラミングを使用して、動的ディスパッチを静的ディスパッチに置き換えることで、実行時オーバーヘッドを削減します。

template<typename T>
void static_dispatch(T& obj) {
    obj.foo(); // 静的ディスパッチ
}

共通の最適化戦略

  • キャッシュの利用：頻繁にアクセスするデータや関数ポインタをキャッシュに格納し、アクセス速度を向上させます。
  • プロファイリング：プロファイリングツールを使用して、ボトルネックを特定し、集中的に最適化を行います。

これらの最適化技法を活用することで、型消去と動的ディスパッチの性能を最大化し、効率的なC++プログラムを構築することができます。

具体的な最適化の例

型消去と動的ディスパッチを最適化する具体的な例を見ていきましょう。このセクションでは、実際のコードを使って、どのように最適化が行われ、性能が向上するのかを示します。

型消去の最適化例：小さなオブジェクトの最適化（SBO）

小さなオブジェクトの最適化を適用することで、メモリ割り当てのオーバーヘッドを削減します。以下に、SBOを実装したSmallAnyクラスの具体例を示します。

#include <iostream>
#include <typeinfo>

template<size_t BufferSize>
class SmallAny {
public:
    template<typename T>
    SmallAny(T value) {
        static_assert(sizeof(T) <= BufferSize, "Type too large for SmallAny buffer");
        new (&buffer) T(value);
        type_info = &typeid(T);
    }

    const std::type_info& type() const { return *type_info; }

    template<typename T>
    T& any_cast() {
        if (type() != typeid(T)) {
            throw std::bad_cast();
        }
        return *reinterpret_cast<T*>(&buffer);
    }

private:
    alignas(BufferSize) char buffer[BufferSize];
    const std::type_info* type_info;
};

int main() {
    SmallAny<16> a = 10; // SBO適用
    std::cout << "Type: " << a.type().name() << ", Value: " << a.any_cast<int>() << std::endl;

    SmallAny<16> b = std::string("Hello, World!"); // SBO適用
    std::cout << "Type: " << b.type().name() << ", Value: " << b.any_cast<std::string>() << std::endl;

    return 0;
}

この例では、SmallAnyクラスを使用して、小さなオブジェクトをスタック上に格納し、動的メモリ割り当てを回避しています。

動的ディスパッチの最適化例：静的ディスパッチの利用

動的ディスパッチを静的ディスパッチに置き換えることで、実行時のオーバーヘッドを削減します。以下に、その具体例を示します。

#include <iostream>

// 基底クラス
class Base {
public:
    virtual ~Base() = default;
    virtual void foo() const {
        std::cout << "Base foo" << std::endl;
    }
};

// 派生クラス Derived
class Derived : public Base {
public:
    void foo() const override {
        std::cout << "Derived foo" << std::endl;
    }
};

// 静的ディスパッチ
template<typename T>
void static_dispatch(T& obj) {
    obj.foo(); // 静的ディスパッチ
}

int main() {
    Derived d;
    static_dispatch(d); // 静的ディスパッチを利用

    return 0;
}

この例では、テンプレート関数static_dispatchを使用して、静的に派生クラスのメソッドを呼び出しています。これにより、動的ディスパッチに伴う実行時の関数ポインタ解決が不要になります。

パフォーマンスの測定

プロファイリングツールを使用して、最適化の効果を測定します。例えば、以下のようにパフォーマンスを計測するコードを追加します。

#include <chrono>

int main() {
    Derived d;

    auto start = std::chrono::high_resolution_clock::now();
    for (int i = 0; i < 1000000; ++i) {
        static_dispatch(d); // 最適化された静的ディスパッチの呼び出し
    }
    auto end = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> elapsed = end - start;

    std::cout << "Elapsed time: " << elapsed.count() << " seconds" << std::endl;

    return 0;
}

このコードを実行することで、静的ディスパッチの最適化がパフォーマンスに与える影響を確認できます。

これらの具体例を通じて、型消去と動的ディスパッチの最適化がどのように行われ、性能が向上するかを理解することができます。これにより、C++プログラムの効率を大幅に改善することが可能です。

型消去のデバッグとトラブルシューティング

型消去の実装においては、いくつかの問題が発生する可能性があります。ここでは、一般的な問題とその解決方法を説明します。

一般的な問題

型消去を実装する際に遭遇しがちな問題には、以下のようなものがあります：

  • 型の不一致：any_castや同様のキャスト操作で、型が一致しない場合にstd::bad_cast例外が発生する。
  • メモリ管理：動的メモリを使用する場合、メモリリークや不適切なメモリ解放が問題になることがあります。
  • パフォーマンスの低下：適切に最適化されていない場合、ランタイムオーバーヘッドが発生し、パフォーマンスが低下することがあります。

問題の解決方法

型の不一致の解決

型の不一致を防ぐためには、型情報を明確に管理することが重要です。以下は、any_castの使用例で、型不一致を防ぐ方法です。

template<typename T>
T& any_cast(SmallAny<16>& a) {
    if (a.type() != typeid(T)) {
        throw std::bad_cast();
    }
    return *reinterpret_cast<T*>(&a.buffer);
}

int main() {
    try {
        SmallAny<16> a = 10;
        std::cout << "Value: " << any_cast<int>(a) << std::endl; // 正常動作

        // 以下の行は型不一致のため例外が発生する
        std::cout << "Value: " << any_cast<std::string>(a) << std::endl; 
    } catch (const std::bad_cast& e) {
        std::cerr << "Caught bad_cast: " << e.what() << std::endl;
    }

    return 0;
}

メモリ管理の改善

動的メモリを使用する場合、std::unique_ptrやstd::shared_ptrなどのスマートポインタを活用してメモリ管理を自動化し、メモリリークを防ぎます。

class Any {
public:
    template<typename T>
    Any(T value) : ptr_(std::make_unique<AnyDerived<T>>(value)) {}

    const std::type_info& type() const { return ptr_->type(); }

    template<typename T>
    T& any_cast() {
        if (type() != typeid(T)) {
            throw std::bad_cast();
        }
        return static_cast<AnyDerived<T>*>(ptr_.get())->value_;
    }

private:
    std::unique_ptr<AnyBase> ptr_;
};

パフォーマンスの最適化

パフォーマンスを向上させるためには、前述した小さなオブジェクトの最適化（SBO）やインプレース構築を活用します。また、頻繁に使用される関数やデータのキャッシュを行い、アクセス速度を向上させます。

template<typename T, typename... Args>
void construct_in_place(void* buffer, Args&&... args) {
    new (buffer) T(std::forward<Args>(args)...);
}

デバッグのツールとテクニック

  • デバッガ：gdbやlldbなどのデバッガを使用して、ランタイムエラーの原因を特定します。
  • サニタイザ：AddressSanitizerやUndefinedBehaviorSanitizerなどのツールを使用して、メモリリークや未定義動作を検出します。
  • プロファイラ：gprofやvalgrindを使用して、パフォーマンスのボトルネックを特定し、最適化の対象を明確にします。

これらの手法とツールを活用することで、型消去の実装における問題を効果的に解決し、安定性とパフォーマンスを向上させることができます。

動的ディスパッチのデバッグとトラブルシューティング

動的ディスパッチの実装においても、いくつかの問題が発生する可能性があります。ここでは、一般的な問題とその解決方法について説明します。

一般的な問題

動的ディスパッチを実装する際に遭遇しがちな問題には、以下のようなものがあります：

  • 仮想関数の呼び出し失敗：仮想関数が正しくオーバーライドされていない場合、基底クラスの関数が呼び出される。
  • パフォーマンスの低下：仮想関数テーブル（VTable）を使用するため、ランタイムオーバーヘッドが発生する。
  • メモリ管理の問題：ポインタを使用するため、メモリリークや解放忘れが発生することがある。

問題の解決方法

仮想関数の呼び出し失敗の解決

仮想関数が正しくオーバーライドされているかどうかを確認するためには、override指定子を使用することが有効です。これにより、コンパイル時に正しくオーバーライドされていない場合にエラーが発生します。

class Base {
public:
    virtual void foo() const = 0;
};

class Derived : public Base {
public:
    void foo() const override { // override指定子を使用
        std::cout << "Derived foo" << std::endl;
    }
};

パフォーマンスの低下の解決

動的ディスパッチのパフォーマンスを最適化するためには、以下の手法が有効です：

  • インライン化：仮想関数の呼び出し回数を減らし、可能な限り関数をインライン化します。
  • 仮想関数の使用を最小限に：頻繁に呼び出される関数は、仮想関数にせず、静的ディスパッチを利用します。
class Base {
public:
    virtual void foo() const {
        // 複雑な処理は避け、シンプルな操作にとどめる
    }
};

class Derived : public Base {
public:
    void foo() const override {
        // シンプルな操作
    }
};

メモリ管理の改善

動的ディスパッチを使用する場合、メモリ管理を自動化するためにスマートポインタを活用します。これにより、メモリリークや解放忘れを防ぎます。

#include <memory>

class Base {
public:
    virtual ~Base() = default;
    virtual void foo() const = 0;
};

class Derived : public Base {
public:
    void foo() const override {
        std::cout << "Derived foo" << std::endl;
    }
};

int main() {
    std::unique_ptr<Base> obj = std::make_unique<Derived>();
    obj->foo(); // 動的ディスパッチ
    return 0;
}

デバッグのツールとテクニック

  • デバッガ：gdbやlldbなどのデバッガを使用して、仮想関数の呼び出しが正しく行われているかを確認します。
  • サニタイザ：AddressSanitizerやUndefinedBehaviorSanitizerなどのツールを使用して、メモリ管理の問題や未定義動作を検出します。
  • プロファイラ：gprofやvalgrindを使用して、動的ディスパッチのパフォーマンスボトルネックを特定し、最適化の対象を明確にします。

これらの手法とツールを活用することで、動的ディスパッチの実装における問題を効果的に解決し、安定性とパフォーマンスを向上させることができます。

応用例と演習問題

ここでは、型消去と動的ディスパッチの応用例と演習問題を通じて、これまで学んだ知識を実際に使ってみましょう。これにより、理解を深めることができます。

応用例：プラグインシステムの設計

型消去と動的ディスパッチを利用して、プラグインシステムを設計してみましょう。この例では、複数のプラグインを動的に読み込み、それぞれの機能を実行します。

プラグインの基底クラス

まず、すべてのプラグインが実装する共通のインターフェースを定義します。

class Plugin {
public:
    virtual ~Plugin() = default;
    virtual void execute() const = 0;
};

具体的なプラグインの実装

次に、いくつかの具体的なプラグインを実装します。

class PluginA : public Plugin {
public:
    void execute() const override {
        std::cout << "PluginA executed." << std::endl;
    }
};

class PluginB : public Plugin {
public:
    void execute() const override {
        std::cout << "PluginB executed." << std::endl;
    }
};

プラグインマネージャの実装

プラグインを管理し、動的に呼び出すためのプラグインマネージャを実装します。

#include <vector>
#include <memory>

class PluginManager {
public:
    void addPlugin(std::unique_ptr<Plugin> plugin) {
        plugins_.emplace_back(std::move(plugin));
    }

    void executeAll() const {
        for (const auto& plugin : plugins_) {
            plugin->execute(); // 動的ディスパッチ
        }
    }

private:
    std::vector<std::unique_ptr<Plugin>> plugins_;
};

int main() {
    PluginManager manager;
    manager.addPlugin(std::make_unique<PluginA>());
    manager.addPlugin(std::make_unique<PluginB>());

    manager.executeAll(); // すべてのプラグインを実行

    return 0;
}

このプラグインシステムでは、プラグインを動的に追加および実行でき、型消去と動的ディスパッチの利点を活かしています。

演習問題

以下の演習問題に取り組むことで、型消去と動的ディスパッチの理解をさらに深めることができます。

演習1：新しいプラグインの追加

新しいプラグインPluginCを実装し、プラグインマネージャに追加して実行してください。

class PluginC : public Plugin {
public:
    void execute() const override {
        std::cout << "PluginC executed." << std::endl;
    }
};

演習2：型消去を利用した汎用コレクションの実装

型消去を利用して、異なる型のオブジェクトを格納できる汎用コレクションを実装してください。以下に簡単な例を示します。

#include <vector>
#include <memory>
#include <typeinfo>
#include <iostream>

class AnyCollection {
public:
    template<typename T>
    void add(T value) {
        items_.emplace_back(std::make_unique<AnyDerived<T>>(value));
    }

    void printAllTypes() const {
        for (const auto& item : items_) {
            std::cout << item->type().name() << std::endl;
        }
    }

private:
    class AnyBase {
    public:
        virtual ~AnyBase() = default;
        virtual const std::type_info& type() const = 0;
    };

    template<typename T>
    class AnyDerived : public AnyBase {
    public:
        AnyDerived(T value) : value_(value) {}
        const std::type_info& type() const override { return typeid(T); }
        T value_;
    };

    std::vector<std::unique_ptr<AnyBase>> items_;
};

int main() {
    AnyCollection collection;
    collection.add(42);
    collection.add(std::string("Hello"));

    collection.printAllTypes(); // 格納されたオブジェクトの型を表示

    return 0;
}

この演習を通じて、型消去と動的ディスパッチの実装と最適化を実践的に学び、C++プログラムの設計と実装能力を向上させましょう。

まとめ

本記事では、C++における型消去と動的ディスパッチの基本概念から、その実装方法、最適化技法、デバッグとトラブルシューティング、応用例や演習問題までを詳細に解説しました。型消去を利用することで、異なる型を統一的に扱うことができ、コードの汎用性と柔軟性が向上します。一方、動的ディスパッチを利用することで、実行時に適切な関数を選択し、多態性を実現します。これらの技術を組み合わせ、適切に最適化することで、高性能かつ柔軟なC++プログラムを構築することが可能です。今回の内容を基に、さらなる実践と学習を通じて、C++の高度な技術をマスターしていきましょう。

C++
最適化 C++ 型消去 動的ディスパッチ

コメント

コメントする

目次