Bridge を C++ で

Bridge は、構造に関するデザインパターンの一つで、ビジネス・ロジックや巨大なクラスを独立して開発可能なクラス階層に分割します。

階層の一つ（抽象化と呼ばれる）は、二つ目の階層（実装）のオブジェクトへの参照を持ちます。抽象化階層は、その呼び出しのいくつか（場合によっては大多数）を実装階層のオブジェクトに委任します。すべての実装は、共通のインターフェースを持っているので、抽象化の中で入れ替え可能です。

Bridge の詳細

複雑度：

人気度：

使用例： Bridge パターンは、クロス・プラットフォーム・アプリを扱う時、複数の種類のデータベース・サーバーをサポートする時、あるいはある種の API プロバイダー（クラウド・プラットフォーム、ソーシャル・ネットワークなど）を複数利用したい場合に特に便利です。

見つけ方： Bridge は、制御するものと、それが依存するいくつかの異なるプラットフォームとが明らかに分かれていることから識別できます。

概念的な例

この例は、 Bridge デザインパターンの構造を説明するためのものです。以下の質問に答えることを目的としています：

どういうクラスからできているか？
それぞれのクラスの役割は？
パターンの要素同士はどう関係しているのか？

main.cc: 概念的な例

/** * The Implementation defines the interface for all implementation classes. It * doesn't have to match the Abstraction's interface. In fact, the two * interfaces can be entirely different. Typically the Implementation interface * provides only primitive operations, while the Abstraction defines higher- * level operations based on those primitives. */ class Implementation { public: virtual ~Implementation() {} virtual std::string OperationImplementation() const = 0; }; /** * Each Concrete Implementation corresponds to a specific platform and * implements the Implementation interface using that platform's API. */ class ConcreteImplementationA : public Implementation { public: std::string OperationImplementation() const override { return "ConcreteImplementationA: Here's the result on the platform A.\n"; } }; class ConcreteImplementationB : public Implementation { public: std::string OperationImplementation() const override { return "ConcreteImplementationB: Here's the result on the platform B.\n"; } }; /** * The Abstraction defines the interface for the "control" part of the two class * hierarchies. It maintains a reference to an object of the Implementation * hierarchy and delegates all of the real work to this object. */ class Abstraction { /** * @var Implementation */ protected: Implementation* implementation_; public: Abstraction(Implementation* implementation) : implementation_(implementation) { } virtual ~Abstraction() { } virtual std::string Operation() const { return "Abstraction: Base operation with:\n" + this->implementation_->OperationImplementation(); } }; /** * You can extend the Abstraction without changing the Implementation classes. */ class ExtendedAbstraction : public Abstraction { public: ExtendedAbstraction(Implementation* implementation) : Abstraction(implementation) { } std::string Operation() const override { return "ExtendedAbstraction: Extended operation with:\n" + this->implementation_->OperationImplementation(); } }; /** * Except for the initialization phase, where an Abstraction object gets linked * with a specific Implementation object, the client code should only depend on * the Abstraction class. This way the client code can support any abstraction- * implementation combination. */ void ClientCode(const Abstraction& abstraction) { // ... std::cout << abstraction.Operation(); // ... } /** * The client code should be able to work with any pre-configured abstraction- * implementation combination. */ int main() { Implementation* implementation = new ConcreteImplementationA; Abstraction* abstraction = new Abstraction(implementation); ClientCode(*abstraction); std::cout << std::endl; delete implementation; delete abstraction; implementation = new ConcreteImplementationB; abstraction = new ExtendedAbstraction(implementation); ClientCode(*abstraction); delete implementation; delete abstraction; return 0; }

Output.txt: 実行結果

Abstraction: Base operation with: ConcreteImplementationA: Here's the result on the platform A. ExtendedAbstraction: Extended operation with: ConcreteImplementationB: Here's the result on the platform B.