MENU
  1. ホーム
  2. C++
  3. C++での循環参照問題とその解決方法を徹底解説

C++での循環参照問題とその解決方法を徹底解説

C++

循環参照とは何か、なぜ問題になるのかを解説します。C++のプログラミングにおいて、オブジェクト同士が互いに参照し合う状況が生まれることがあります。この状況は「循環参照」と呼ばれ、メモリ管理やリソースの解放において大きな問題を引き起こす可能性があります。特に、スマートポインタ（shared_ptr）を使用する場合、循環参照が発生すると自動的なメモリ解放が行われず、メモリリークが発生します。この記事では、循環参照の問題点とその解決方法について詳しく説明します。

目次

循環参照の基本概念

循環参照は、二つ以上のオブジェクトが互いに参照し合う状況を指します。具体的には、オブジェクトAがオブジェクトBを参照し、同時にオブジェクトBもオブジェクトAを参照している場合を考えます。このような参照の連鎖が形成されると、各オブジェクトの参照カウントが減少しなくなり、自動的にメモリを解放する仕組みが機能しなくなります。この結果、メモリが解放されないまま残り続ける「メモリリーク」が発生します。循環参照は、特に複雑なデータ構造や長期間稼働するアプリケーションで重大な問題を引き起こすため、その理解と対策が重要です。

循環参照が引き起こす問題

循環参照が発生すると、主に以下のような問題が生じます。

メモリリーク

循環参照により、オブジェクトの参照カウントが0にならないため、自動的にメモリが解放されなくなります。この結果、不要になったオブジェクトがメモリ上に残り続け、メモリリークを引き起こします。メモリリークが蓄積すると、最終的にはシステムのメモリが不足し、アプリケーションのパフォーマンス低下やクラッシュを招く可能性があります。

リソース管理の複雑化

循環参照が存在すると、リソースのライフサイクル管理が非常に複雑になります。開発者は手動で参照カウントを調整したり、特殊な対策を講じたりする必要があり、コードの保守性が低下します。

パフォーマンスの低下

メモリリークによって利用可能なメモリが減少すると、システム全体のパフォーマンスが低下します。また、循環参照を解消するための追加のコードが必要となり、これがオーバーヘッドとなる場合もあります。

循環参照は、見過ごされがちな問題ですが、長期的なシステム運用や複雑なアプリケーション開発において深刻な影響を及ぼすため、早期の対策が重要です。

スマートポインタの役割

C++でメモリ管理を効率的に行うために、スマートポインタが重要な役割を果たします。スマートポインタは、標準ライブラリで提供されるテンプレートクラスであり、動的メモリの管理を自動化します。これにより、開発者は手動でメモリの割り当てや解放を行う必要がなくなり、メモリリークやダングリングポインタのリスクが大幅に減少します。

shared_ptrとunique_ptr

スマートポインタにはいくつかの種類がありますが、特に重要なのがshared_ptrとunique_ptrです。shared_ptrは、複数の所有者が同じオブジェクトを共有する場合に使用されます。shared_ptrは参照カウントを保持し、全ての所有者がオブジェクトを参照しなくなった時点で自動的にメモリを解放します。一方、unique_ptrは唯一の所有者を持つスマートポインタであり、所有権を他のunique_ptrに移動することはできますが、コピーは許されません。

循環参照の問題点

shared_ptrを使用すると、循環参照が発生した場合に参照カウントがゼロにならず、メモリが解放されない問題が発生します。このため、shared_ptrだけでなく、循環参照を回避するためのweak_ptrも併用することが重要です。次のセクションでは、weak_ptrの利用方法について詳しく解説します。

weak_ptrの利用方法

循環参照を避けるために、C++ではweak_ptrを利用します。weak_ptrは、shared_ptrと連携して使用されるスマートポインタで、参照カウントに影響を与えずにオブジェクトへの弱い参照を保持します。これにより、循環参照を防ぎつつ、安全にオブジェクトを参照することができます。

weak_ptrの基本的な使い方

weak_ptrは、shared_ptrから作成されます。以下のコード例では、shared_ptrとweak_ptrの基本的な使い方を示します。

#include <iostream>
#include <memory>

class Node {
public:
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev; // 弱い参照

    Node() {
        std::cout << "Node created" << std::endl;
    }

    ~Node() {
        std::cout << "Node destroyed" << std::endl;
    }
};

int main() {
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();

    node1->next = node2;
    node2->prev = node1; // weak_ptrを使用して循環参照を防ぐ

    return 0;
}

この例では、Nodeクラスが双方向リストのノードを表しています。node1とnode2は互いに参照し合っていますが、node2のprevメンバはweak_ptrを使用しているため、循環参照が発生しません。これにより、main関数の終了時に両方のノードが正しく解放されます。

weak_ptrのロックと有効性の確認

weak_ptrは直接オブジェクトにアクセスすることはできませんが、lock()メソッドを使用してshared_ptrに変換することができます。また、expired()メソッドを使用してオブジェクトが有効かどうかを確認することもできます。

if (auto sp = node2->prev.lock()) {
    // weak_ptrが有効な場合、shared_ptrに変換
    std::cout << "Previous node is valid" << std::endl;
} else {
    std::cout << "Previous node has been destroyed" << std::endl;
}

この方法により、weak_ptrが指すオブジェクトがまだ有効かどうかを確認し、安全にアクセスすることができます。weak_ptrを適切に活用することで、循環参照を回避し、効率的なメモリ管理を実現できます。

具体例：shared_ptrとweak_ptrの併用

循環参照を避けるために、shared_ptrとweak_ptrをどのように併用するかについて、具体的なコード例を示します。ここでは、双方向リンクリストを例に取り上げます。

クラス定義

まず、Nodeクラスを定義し、次のノードへの参照をshared_ptrで、前のノードへの参照をweak_ptrで管理します。

#include <iostream>
#include <memory>

class Node {
public:
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev; // 弱い参照

    Node() {
        std::cout << "Node created" << std::endl;
    }

    ~Node() {
        std::cout << "Node destroyed" << std::endl;
    }
};

ノードの作成とリンク

次に、main関数内でノードを作成し、リンクを設定します。

int main() {
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();

    node1->next = node2;
    node2->prev = node1; // weak_ptrを使用して循環参照を防ぐ

    // node1およびnode2がmain関数のスコープを抜けるときに、正しく解放されることを確認
    return 0;
}

この例では、node1とnode2が互いに参照し合っていますが、node2のprevメンバはweak_ptrを使用しているため、循環参照が発生しません。これにより、main関数の終了時に両方のノードが正しく解放されます。

weak_ptrの使用例

さらに、weak_ptrを使用して安全に前のノードにアクセスする方法を示します。

void printPreviousNode(const std::shared_ptr<Node>& node) {
    if (auto prevNode = node->prev.lock()) {
        std::cout << "Previous node is valid" << std::endl;
    } else {
        std::cout << "Previous node has been destroyed" << std::endl;
    }
}

int main() {
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();

    node1->next = node2;
    node2->prev = node1; // weak_ptrを使用して循環参照を防ぐ

    printPreviousNode(node2);

    return 0;
}

この関数では、weak_ptrのlock()メソッドを使用して前のノードにアクセスし、有効であるかどうかを確認します。これにより、参照先のオブジェクトが解放されている場合でも安全に処理を行うことができます。

このように、shared_ptrとweak_ptrを適切に併用することで、循環参照を回避しつつ、効率的で安全なメモリ管理を実現できます。

自動テストでの循環参照検出

循環参照を早期に検出し、回避するために、自動テストを導入することは非常に有効です。ここでは、C++での循環参照検出のための自動テスト設定方法を紹介します。

Google Testの導入

C++で自動テストを行うための代表的なフレームワークにGoogle Testがあります。まず、Google Testをプロジェクトに導入し、基本的なテスト環境を整えます。

# CMakeLists.txt
cmake_minimum_required(VERSION 3.10)
project(CircularReferenceTest)

set(CMAKE_CXX_STANDARD 17)

# Google Testのダウンロードとインクルード
include(FetchContent)
FetchContent_Declare(
  googletest
  URL https://github.com/google/googletest/archive/release-1.10.0.zip
)
FetchContent_MakeAvailable(googletest)

enable_testing()

add_executable(
  CircularReferenceTest
  main.cpp
  Node.cpp
)

target_link_libraries(
  CircularReferenceTest
  gtest_main
)

include(GoogleTest)
gtest_discover_tests(CircularReferenceTest)

テストコードの作成

次に、循環参照を検出するためのテストコードを作成します。ここでは、Nodeクラスに対する基本的なテストを示します。

// Node.h
#pragma once
#include <memory>

class Node {
public:
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev; // 弱い参照

    Node();
    ~Node();
};

// Node.cpp
#include "Node.h"
#include <iostream>

Node::Node() {
    std::cout << "Node created" << std::endl;
}

Node::~Node() {
    std::cout << "Node destroyed" << std::endl;
}

// main.cpp
#include <gtest/gtest.h>
#include "Node.h"

TEST(CircularReferenceTest, BasicTest) {
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();

    node1->next = node2;
    node2->prev = node1; // weak_ptrを使用して循環参照を防ぐ

    EXPECT_EQ(node1->next, node2);
    EXPECT_FALSE(node2->prev.expired());
}

int main(int argc, char **argv) {
    ::testing::InitGoogleTest(&argc, argv);
    return RUN_ALL_TESTS();
}

テストの実行

CMakeを使用してビルドし、テストを実行します。これにより、循環参照が正しく解決されていることを確認できます。

mkdir build
cd build
cmake ..
make
./CircularReferenceTest

このテストでは、node1とnode2が適切にリンクされており、weak_ptrが正しく機能していることを確認します。weak_ptrがexpiredでないことをテストすることで、循環参照が発生していないことを保証します。

自動テストを導入することで、循環参照の問題を早期に検出し、コードの信頼性と品質を向上させることができます。

循環参照を回避するデザインパターン

循環参照を回避するための設計段階での対策として、いくつかのデザインパターンが有効です。ここでは、代表的なデザインパターンを紹介します。

Observerパターン

Observerパターンは、オブジェクトが他のオブジェクトの状態変化を監視するためのパターンです。このパターンを使用すると、オブジェクト間の強い依存関係を避け、循環参照のリスクを減らすことができます。

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

class Observer {
public:
    virtual void onNotify() = 0;
};

class Subject {
public:
    void addObserver(std::shared_ptr<Observer> observer) {
        observers.push_back(observer);
    }

    void notify() {
        for (auto& observer : observers) {
            if (auto obs = observer.lock()) {
                obs->onNotify();
            }
        }
    }

private:
    std::vector<std::weak_ptr<Observer>> observers; // weak_ptrを使用
};

class ConcreteObserver : public Observer {
public:
    void onNotify() override {
        std::cout << "Observer notified" << std::endl;
    }
};

int main() {
    auto subject = std::make_shared<Subject>();
    auto observer = std::make_shared<ConcreteObserver>();

    subject->addObserver(observer);
    subject->notify();

    return 0;
}

この例では、SubjectクラスがObserverを管理しますが、weak_ptrを使用することで循環参照を回避しています。

Dependency Injection

Dependency Injection（依存性注入）は、オブジェクトの依存関係を外部から注入する設計パターンです。これにより、オブジェクト間の直接的な依存を減らし、循環参照を防ぐことができます。

#include <iostream>
#include <memory>

class Service {
public:
    void execute() {
        std::cout << "Service executed" << std::endl;
    }
};

class Client {
public:
    Client(std::shared_ptr<Service> service) : service(service) {}

    void doWork() {
        service->execute();
    }

private:
    std::shared_ptr<Service> service;
};

int main() {
    auto service = std::make_shared<Service>();
    Client client(service);

    client.doWork();

    return 0;
}

この例では、ClientクラスがServiceクラスに依存していますが、依存性は外部から注入されるため、循環参照が発生しません。

Factoryパターン

Factoryパターンは、オブジェクトの生成を専門とするクラスを使用するパターンです。これにより、生成されたオブジェクト間の依存関係を明確にし、循環参照を回避できます。

#include <iostream>
#include <memory>

class Product {
public:
    void use() {
        std::cout << "Product used" << std::endl;
    }
};

class Factory {
public:
    static std::shared_ptr<Product> createProduct() {
        return std::make_shared<Product>();
    }
};

int main() {
    auto product = Factory::createProduct();
    product->use();

    return 0;
}

この例では、FactoryクラスがProductオブジェクトを生成し、クライアントがそれを使用します。生成と使用の責務を分離することで、循環参照のリスクを軽減しています。

これらのデザインパターンを適用することで、設計段階から循環参照を防止し、健全なメモリ管理を実現することができます。

実際のプロジェクトでの事例

循環参照問題は実際のプロジェクトでも頻繁に発生します。ここでは、実際にあった循環参照問題の事例と、その解決方法を紹介します。

事例1：GUIアプリケーションでの循環参照

あるGUIアプリケーションでは、ウィジェット間の相互参照が原因で循環参照が発生しました。このアプリケーションは、親ウィジェットが子ウィジェットをshared_ptrで保持し、子ウィジェットも親ウィジェットをshared_ptrで参照していました。これにより、ウィジェットの破棄が正しく行われず、メモリリークが発生しました。

解決方法

この問題を解決するために、子ウィジェットが親ウィジェットを参照する際にweak_ptrを使用するように変更しました。具体的には、次のようにコードを修正しました。

class Widget {
public:
    std::shared_ptr<Widget> parent;
    std::vector<std::shared_ptr<Widget>> children;

    Widget() {
        std::cout << "Widget created" << std::endl;
    }

    ~Widget() {
        std::cout << "Widget destroyed" << std::endl;
    }
};

// 修正後
class Widget {
public:
    std::weak_ptr<Widget> parent; // 弱い参照に変更
    std::vector<std::shared_ptr<Widget>> children;

    Widget() {
        std::cout << "Widget created" << std::endl;
    }

    ~Widget() {
        std::cout << "Widget destroyed" << std::endl;
    }
};

この変更により、親ウィジェットが破棄されるときに子ウィジェットのweak_ptrが自動的に無効になり、循環参照が解消されました。

事例2：ネットワークアプリケーションでの循環参照

ネットワークアプリケーションでは、クライアントとサーバー間の相互参照が循環参照を引き起こしました。クライアントがサーバーのインスタンスをshared_ptrで保持し、サーバーもクライアントのインスタンスをshared_ptrで参照していました。

解決方法

この問題を解決するために、サーバーがクライアントを参照する際にweak_ptrを使用するように変更しました。次のようにコードを修正しました。

class Client {
public:
    std::shared_ptr<Server> server;

    Client(const std::shared_ptr<Server>& srv) : server(srv) {}
};

class Server {
public:
    std::shared_ptr<Client> client;

    Server(const std::shared_ptr<Client>& cli) : client(cli) {}
};

// 修正後
class Client {
public:
    std::shared_ptr<Server> server;

    Client(const std::shared_ptr<Server>& srv) : server(srv) {}
};

class Server {
public:
    std::weak_ptr<Client> client; // 弱い参照に変更

    Server(const std::shared_ptr<Client>& cli) : client(cli) {}
};

この変更により、サーバーがクライアントを参照する際にweak_ptrを使用することで、循環参照を解消しました。

事例3：ゲームエンジンでの循環参照

あるゲームエンジンプロジェクトでは、ゲームオブジェクト間の相互参照が原因で循環参照が発生しました。特に、オブジェクトが親子関係にある場合、親が子をshared_ptrで保持し、子も親をshared_ptrで参照していました。

解決方法

この問題を解決するために、子オブジェクトが親オブジェクトを参照する際にweak_ptrを使用するように変更しました。

class GameObject {
public:
    std::shared_ptr<GameObject> parent;
    std::vector<std::shared_ptr<GameObject>> children;

    GameObject() {
        std::cout << "GameObject created" << std::endl;
    }

    ~GameObject() {
        std::cout << "GameObject destroyed" << std::endl;
    }
};

// 修正後
class GameObject {
public:
    std::weak_ptr<GameObject> parent; // 弱い参照に変更
    std::vector<std::shared_ptr<GameObject>> children;

    GameObject() {
        std::cout << "GameObject created" << std::endl;
    }

    ~GameObject() {
        std::cout << "GameObject destroyed" << std::endl;
    }
};

この変更により、親オブジェクトが破棄されるときに子オブジェクトのweak_ptrが自動的に無効になり、循環参照が解消されました。

これらの事例を通じて、循環参照の問題がどのように発生し、どのように解決できるかを具体的に理解することができます。実際のプロジェクトでも、これらの方法を応用して循環参照を回避することが重要です。

応用例：複雑なデータ構造での循環参照回避

循環参照は、複雑なデータ構造でも発生する可能性があります。ここでは、特に注意が必要な複雑なデータ構造での循環参照回避の具体的な方法を解説します。

シーングラフでの循環参照回避

シーングラフは、ゲームや3Dアプリケーションでよく使われるデータ構造です。シーングラフでは、ノードが親子関係を持ち、それぞれが互いを参照することが一般的です。この場合、循環参照が発生しやすいです。

class SceneNode {
public:
    std::weak_ptr<SceneNode> parent; // 親ノードを弱い参照で保持
    std::vector<std::shared_ptr<SceneNode>> children; // 子ノードを強い参照で保持

    SceneNode() {
        std::cout << "SceneNode created" << std::endl;
    }

    ~SceneNode() {
        std::cout << "SceneNode destroyed" << std::endl;
    }

    void addChild(const std::shared_ptr<SceneNode>& child) {
        child->parent = shared_from_this(); // 子ノードの親を設定
        children.push_back(child); // 子ノードを追加
    }
};

int main() {
    auto root = std::make_shared<SceneNode>();
    auto child1 = std::make_shared<SceneNode>();
    auto child2 = std::make_shared<SceneNode>();

    root->addChild(child1);
    root->addChild(child2);

    return 0;
}

この例では、親ノードを弱い参照で保持し、子ノードを強い参照で保持することで循環参照を回避しています。

グラフデータ構造での循環参照回避

グラフデータ構造は、ノードが互いに自由に接続されるため、循環参照が発生しやすいデータ構造です。

class GraphNode {
public:
    std::vector<std::weak_ptr<GraphNode>> neighbors; // 隣接ノードを弱い参照で保持

    GraphNode() {
        std::cout << "GraphNode created" << std::endl;
    }

    ~GraphNode() {
        std::cout << "GraphNode destroyed" << std::endl;
    }

    void addNeighbor(const std::shared_ptr<GraphNode>& neighbor) {
        neighbors.push_back(neighbor); // 隣接ノードを追加
    }
};

int main() {
    auto node1 = std::make_shared<GraphNode>();
    auto node2 = std::make_shared<GraphNode>();
    auto node3 = std::make_shared<GraphNode>();

    node1->addNeighbor(node2);
    node2->addNeighbor(node3);
    node3->addNeighbor(node1); // 循環参照の形成

    return 0;
}

この例では、隣接ノードを弱い参照で保持することで循環参照を回避しています。

カスタムデータ構造での循環参照回避

独自に設計したデータ構造でも、循環参照を回避するためにweak_ptrを適切に使用することが重要です。

class CustomNode {
public:
    std::weak_ptr<CustomNode> parent;
    std::vector<std::shared_ptr<CustomNode>> children;

    CustomNode() {
        std::cout << "CustomNode created" << std::endl;
    }

    ~CustomNode() {
        std::cout << "CustomNode destroyed" << std::endl;
    }

    void addChild(const std::shared_ptr<CustomNode>& child) {
        child->parent = shared_from_this();
        children.push_back(child);
    }
};

int main() {
    auto root = std::make_shared<CustomNode>();
    auto child = std::make_shared<CustomNode>();

    root->addChild(child);

    return 0;
}

この例でも、親ノードを弱い参照で保持し、子ノードを強い参照で保持することで循環参照を回避しています。

これらの応用例を参考に、複雑なデータ構造でも循環参照を回避し、メモリ管理を効率的に行うことができます。weak_ptrを適切に活用することで、循環参照の問題を効果的に解決することができます。

演習問題：循環参照を解決する

循環参照の問題を理解し、実際に解決するための演習問題を提供します。以下の演習を通じて、weak_ptrの使用方法と循環参照の回避方法を実践してみましょう。

演習1: 基本的な循環参照の検出と解決

次のコードには、循環参照の問題があります。これを修正して、循環参照を回避してください。

#include <iostream>
#include <memory>

class A {
public:
    std::shared_ptr<class B> bPtr;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::shared_ptr<A> aPtr;
    ~B() { std::cout << "B destroyed" << std::endl; }
};

int main() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();

    a->bPtr = b;
    b->aPtr = a;

    return 0;
}

解決方法:
上記のコードを修正して、AとBの間の循環参照を回避してください。

解答例:

#include <iostream>
#include <memory>

class A {
public:
    std::shared_ptr<class B> bPtr;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::weak_ptr<A> aPtr; // weak_ptrに変更
    ~B() { std::cout << "B destroyed" << std::endl; }
};

int main() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();

    a->bPtr = b;
    b->aPtr = a;

    return 0;
}

演習2: 双方向リンクリストでの循環参照の解消

次の双方向リンクリストの実装には、循環参照の問題があります。これを修正して、循環参照を回避してください。

#include <iostream>
#include <memory>

class Node {
public:
    std::shared_ptr<Node> next;
    std::shared_ptr<Node> prev;
    ~Node() { std::cout << "Node destroyed" << std::endl; }
};

int main() {
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();

    node1->next = node2;
    node2->prev = node1;

    return 0;
}

解決方法:
上記のコードを修正して、Nodeクラスの循環参照を回避してください。

解答例:

#include <iostream>
#include <memory>

class Node {
public:
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev; // weak_ptrに変更
    ~Node() { std::cout << "Node destroyed" << std::endl; }
};

int main() {
    auto node1 = std::make_shared<Node>();
    auto node2 = std::make_shared<Node>();

    node1->next = node2;
    node2->prev = node1;

    return 0;
}

演習3: カスタムデータ構造での循環参照回避

次のカスタムデータ構造では、循環参照が発生しています。これを修正して、循環参照を回避してください。

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

class TreeNode {
public:
    std::shared_ptr<TreeNode> parent;
    std::vector<std::shared_ptr<TreeNode>> children;
    ~TreeNode() { std::cout << "TreeNode destroyed" << std::endl; }
};

int main() {
    auto root = std::make_shared<TreeNode>();
    auto child = std::make_shared<TreeNode>();

    root->children.push_back(child);
    child->parent = root;

    return 0;
}

解決方法:
上記のコードを修正して、TreeNodeクラスの循環参照を回避してください。

解答例:

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

class TreeNode {
public:
    std::weak_ptr<TreeNode> parent; // weak_ptrに変更
    std::vector<std::shared_ptr<TreeNode>> children;
    ~TreeNode() { std::cout << "TreeNode destroyed" << std::endl; }
};

int main() {
    auto root = std::make_shared<TreeNode>();
    auto child = std::make_shared<TreeNode>();

    root->children.push_back(child);
    child->parent = root;

    return 0;
}

これらの演習を通じて、循環参照の問題を解決するスキルを身につけてください。weak_ptrを適切に使用することで、複雑なデータ構造でも安全かつ効率的なメモリ管理を実現できます。

まとめ

循環参照は、C++のメモリ管理において重大な問題を引き起こす可能性があります。特に、shared_ptrを使用する際には、循環参照を意識してweak_ptrを適切に使用することが重要です。本記事では、循環参照の基本概念から具体的な解決方法までを詳しく解説しました。スマートポインタの役割やweak_ptrの利用方法、実際のプロジェクトでの事例、応用例、演習問題を通じて、循環参照を回避するための実践的な知識とスキルを身につけることができたと思います。これらの知識を活用し、健全で効率的なメモリ管理を実現してください。

C++
メモリ管理 C++ 循環参照

コメント

コメントする

目次