C++ 桥接模式讲解和代码示例
桥接是一种结构型设计模式， 可将业务逻辑或一个大类拆分为不同的层次结构， 从而能独立地进行开发。
层次结构中的第一层 （通常称为抽象部分） 将包含对第二层 （实现部分） 对象的引用。 抽象部分将能将一些 （有时是绝大部分） 对自己的调用委派给实现部分的对象。 所有的实现部分都有一个通用接口， 因此它们能在抽象部分内部相互替换。
复杂度：
流行度：
使用示例： 桥接模式在处理跨平台应用、 支持多种类型的数据库服务器或与多个特定种类 （例如云平台和社交网络等） 的 API 供应商协作时会特别有用。
识别方法： 桥接可以通过一些控制实体及其所依赖的多个不同平台之间的明确区别来进行识别。
概念示例
本例说明了桥接设计模式的结构并重点回答了下面的问题：
- 它由哪些类组成？
- 这些类扮演了哪些角色？
- 模式中的各个元素会以何种方式相互关联？
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. 
