![\"patterns\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/06\/patterns.png\")
<\/p>\nThe Bridge Pattern is a structural pattern. It decouples the interface from the implementation. In C++, a simplified version is often used: the Pimpl Idiom.<\/p>\n
<\/p>\n
<\/p>\n
Before I write about the Pimpl Idiom, here are the fact about the Bridge Pattern<\/p>\n
![\"Bridge\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/10\/Bridge.png\")
<\/p>\n
<\/p>\n
The Bridge Pattern has two hierarchies. One hierarchy for the abstraction (interface), and one for the implementation. The client programs against the abstraction, and the abstraction uses the implementation. Consequently, different implementations of the abstraction interface and implementation interface can be used transparently. The Bridge Pattern provides big flexibility because the abstraction and implementation can be varied and exchanged during the program’s run time.<\/p>\n The Bridge Pattern is a powerful example exemplifying the combination of inheritance and composition. On one hand, it has two type hierarchies (inheritance); on the other hand, the abstraction has an implementation (composition).<\/p>\n The example shows a straightforward implementation of the Bridge Pattern.<\/p>\n <\/p>\n <\/p>\n The class The following screenshot shows the output of the program.<\/p>\n In C++, a simplified version of the Bridge Pattern is often used.<\/p>\n The key idea of the Pimpl Idiom is that the implementation of the class is hidden behind a pointer.<\/p>\n Here is a recipe for implementing the Pimpl Idiom:<\/p>\nAbstraction<\/code><\/strong><\/p>\n\n
Implementor<\/code><\/li>\n<\/ul>\nRedefinedAbstraction<\/code><\/strong><\/p>\n\n
Abstraction<\/code><\/li>\n<\/ul>\nImplementor<\/code><\/strong><\/p>\n\n
ConcreteImplementor<\/code><\/strong><\/p>\n\n
Implementor<\/code><\/li>\n<\/ul>\n<\/span>Example<\/span><\/h3>\n
\n\/\/ bridge.cpp<\/span>\n\n#include <iostream><\/span>\n\nclass<\/span> Implementor<\/span> { \/\/ (1)<\/span>\npublic:<\/span>\n virtual<\/span> void<\/span> implementation() const<\/span> =<\/span> 0<\/span>;\n\n virtual<\/span> ~<\/span>Implementor() =<\/span> default<\/span>;\n};\n \nclass<\/span> ImplementorA<\/span>:<\/span> public<\/span> Implementor {\npublic:<\/span>\n ImplementorA() =<\/span> default<\/span>;\n \n void<\/span> implementation() const<\/span> {\n std::<\/span>cout <<<\/span> \"ImplementatorA::implementation\"<\/span> <<<\/span> '\\n'<\/span>;\n }\n};\n \nclass<\/span> ImplementorB<\/span>:<\/span> public<\/span> Implementor {\npublic:<\/span>\n ImplementorB() =<\/span> default<\/span>;\n\n void<\/span> implementation() const<\/span> {\n std::<\/span>cout <<<\/span> \"ImplementatorB::implementation\"<\/span> <<<\/span> '\\n'<\/span>;\n }\n};\n\nclass<\/span> Abstraction<\/span> { \/\/ (2) <\/span>\npublic:<\/span>\n virtual<\/span> void<\/span> function() const<\/span> =<\/span> 0<\/span>;\n virtual<\/span> ~<\/span>Abstraction() =<\/span> default<\/span>;\n};\n\nclass<\/span> RefinedAbstraction<\/span>:<\/span> public<\/span> Abstraction {\npublic:<\/span>\n RefinedAbstraction(Implementor&<\/span> impl) :<\/span> \n\t\timplementor(impl) {\n }\n \n void<\/span> function() const<\/span> {\n std::<\/span>cout <<<\/span> \"RefinedAbstraction::function<\/span>\\n<\/span>\"<\/span>;\n implementor.implementation();\n }\nprivate:<\/span>\n Implementor&<\/span> implementor;\n};\n \nint<\/span> main<\/span>() {\n\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n ImplementorA implementorA;\n ImplementorB implementorB;\n \n RefinedAbstraction refinedAbstraction1(implementorA); \/\/ (3)<\/span>\n RefinedAbstraction refinedAbstraction2(implementorB); \/\/ (4)<\/span>\n\n Abstraction *<\/span>abstraction1 =<\/span> &<\/span>refinedAbstraction1;\n Abstraction *<\/span>abstraction2 =<\/span> &<\/span>refinedAbstraction2;\n\n abstraction1-><\/span>function();\n\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n abstraction2-><\/span>function();\n\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\n\n}\n<\/pre>\n<\/div>\nImplementor<\/code> (line 1) is the interface for the implementation hierarchy, and the class Abstraction<\/code> (line 2) is the interface of the abstraction. The instances redefinedAbstraction1<\/code> and redefinedAbstraction2<\/code> get their implementation in its constructor (lines 3 and 4).<\/p>\n![\"bridgeExample\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/10\/bridgeExample.png\")
<\/p>\n<\/span>Related Patterns<\/span><\/h3>\n
\n
<\/span>The Pimpl Idiom<\/span><\/h2>\n
\n