The idea of the adapter pattern is straightforward: It converts the interface of a class into another interface.<\/p>\n
<\/p>\n
![\"patterns\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/06\/patterns.png\")
Imagine you have a class that implements the functionality required by the client. There is only one issue: the interface does not follow your company’s naming policy. Thanks to the Adapter Pattern, you can pretty easily support the required interface using the existing class.<\/p>\n
The Adapter Pattern is the only pattern inside the book “Design Patterns: Elements of Reusable Object-Oriented Software”<\/a> (Design Pattern) that is implemented on a class level but also on an object level. Here are the facts before I show you both ways to implement this structural pattern.<\/p>\n The container adapters s <\/p>\n <\/p>\n By default, C++ has more adapters.<\/p>\n C++ supports insert iterators and streams iterators.<\/p>\n With the three insert iterators Stream iterator<\/a> adapters can use streams as a data source or data sink. C++ offers two functions to create istream iterators and two to create ostream iterators. The created istream iterators behave like input iterators<\/a>, the ostream iterators like insert iterators<\/a>.<\/p>\n The following two class diagrams show the structure of the Adapter Pattern, based on classes or on objects. For short, I call them class adapters and object adapters.<\/p>\n <\/p>\n Now, the class or object based Adapter Pattern should be straightforward.<\/p>\n<\/p>\n In the following example, the class <\/p>\n <\/p>\n This implementation of the Adapter Pattern is one of the rare use cases for private inheritance. Let me write a few words about interface inheritance and implementation inheritance.<\/p>\n<\/span>The Adapter Pattern<\/span><\/h2>\n
<\/span>Purpose<\/span><\/h3>\n
\n
<\/span>Also known as<\/span><\/h3>\n
\n
<\/span>Use Case<\/span><\/h3>\n
\n
<\/span>Example<\/span><\/h3>\n
Container Adapter<\/h4>\n
td::stack<\/code><\/a>, std::queue<\/a>,<\/code> and std::priority_queue<\/a><\/code> provide a different interface for the sequence containers. The following code snippet shows the template signature of the three container adapters:<\/p>\n\ntemplate<\/span><<\/span>typename<\/span> T, typename<\/span> Container =<\/span> std::<\/span>deque<<\/span>T>><\/span> \r\nclass<\/span> stack<\/span>;\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T, typename<\/span> Container =<\/span> std::<\/span>deque<<\/span>T>><\/span> \r\nclass<\/span> queue<\/span>;\r\n\r\ntemplate<\/span><<\/span>typename<\/span> T, typename<\/span> Container =<\/span> std::<\/span>vector<<\/span>T><\/span>, \r\n typename<\/span> Compare =<\/span> std::<\/span>less<<\/span>typename<\/span> Container::<\/span>value_type>><\/span> \r\nclass<\/span> priority_queue<\/span>;\r\n<\/pre>\n<\/div>\n std::stack<\/a>,<\/code> and std::queue<\/a><\/code> use std::deque<\/a><\/code> as sequence container, but std::priority_queue<\/a><\/code> uses std::vector<\/a><\/code>. Additionally, std::priority_queue<\/a> <\/code>also requires a comparator that is defaulted to std::less<\/code> of the sequence container elements.<\/p>\nIterator Adapter<\/h4>\n
\n
std::front_inserter<\/code><\/a>, std::back_inserter<\/code>, and std::inserter,<\/code> you can insert an element into a container at the beginning, at the end or an arbitrary position, respectively.<\/p>\n\n
<\/span>Structure<\/span><\/h3>\n
Class Adapter<\/h4>\n
![\"AdapterrClass\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2017\/10\/AdapterrClass.png\")
<\/p>\nObject Adapter<\/h4>\n
![\"AdapterObject\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/10\/AdapterObject.png\")
<\/p>\nClient<\/code><\/p>\n\n
methodA()<\/code> of the Adapter<\/code><\/li>\n<\/ul>\nAdaptor<\/code><\/p>\n\n
\n
methodA()<\/code> using multiple inheritances<\/li>\nInterface<\/code> and privately from Implementation<\/code><\/li>\n<\/ul>\n<\/li>\n\n
Adaptee<\/code><\/li>\n<\/ul>\n<\/li>\n<\/ul>\nAdaptee<\/code><\/p>\n\n
<\/span>Implementation<\/span><\/h2>\n
<\/span>Class Adapter<\/span><\/h3>\n
RectangleAdapter<\/code> adapts the interface of the LegacyRectangle<\/code>.<\/p>\n\n\/\/ adapterClass.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n\r\ntypedef<\/span> int<\/span> Coordinate;\r\ntypedef<\/span> int<\/span> Dimension;\r\n\r\nclass<\/span> Rectangle<\/span> {\r\npublic:<\/span>\r\n virtual<\/span> void<\/span> draw() =<\/span> 0<\/span>;\r\n virtual<\/span> ~<\/span>Rectangle() =<\/span> default<\/span>;\r\n};\r\n\r\nclass<\/span> LegacyRectangle<\/span> {\r\n public:<\/span>\r\n LegacyRectangle(Coordinate x1, Coordinate y1, Coordinate x2, Coordinate y2) :<\/span> x1_(x1), y1_(y1), x2_(x2), y2_(y2){\r\n std::<\/span>cout <<<\/span> \"LegacyRectangle: create. (\"<\/span> <<<\/span> x1_ <<<\/span> \",\"<\/span> <<<\/span> y1_ <<<\/span> \") => (\"<\/span>\r\n <<<\/span> x2_ <<<\/span> \",\"<\/span> <<<\/span> y2_ <<<\/span> \")\"<\/span> <<<\/span> '\\n'<\/span>;\r\n }\r\n\r\n void<\/span> oldDraw() {\r\n std::<\/span>cout <<<\/span> \"LegacyRectangle: oldDraw. (\"<\/span> <<<\/span> x1_ <<<\/span> \",\"<\/span> <<<\/span> y1_ \r\n <<<\/span> \") => (\"<\/span> <<<\/span> x2_ <<<\/span> \",\"<\/span> <<<\/span> y2_ <<<\/span> \")\"<\/span> <<<\/span> '\\n'<\/span>;\r\n }\r\n\r\n private:<\/span>\r\n Coordinate x1_;\r\n Coordinate y1_;\r\n Coordinate x2_;\r\n Coordinate y2_;\r\n};\r\n\r\n\r\nclass<\/span> RectangleAdapter<\/span> :<\/span> public<\/span> Rectangle, private<\/span> LegacyRectangle {\r\n public:<\/span>\r\n RectangleAdapter(Coordinate x, Coordinate y, Dimension w, Dimension h) :<\/span> LegacyRectangle(x, y, x +<\/span> w, y +<\/span> h) { \/\/ (1)<\/em><\/span>\r\n std::<\/span>cout <<<\/span> \"RectangleAdapter: create. (\"<\/span> <<<\/span> x <<<\/span> \",\"<\/span> <<<\/span> y \r\n <<<\/span> \"), width = \"<\/span> <<<\/span> w <<<\/span> \", height = \"<\/span> <<<\/span> h <<<\/span> '\\n'<\/span>;\r\n }\r\n\r\n void<\/span> draw() override {\r\n oldDraw();\r\n std::<\/span>cout <<<\/span> \"RectangleAdapter: draw.\"<\/span> <<<\/span> '\\n'<\/span>;\r\n }\r\n};\r\n\r\nint<\/span> main<\/span>() {\r\n\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n Rectangle*<\/span> r =<\/span> new<\/span> RectangleAdapter(120<\/span>, 200<\/span>, 60<\/span>, 40<\/span>);\r\n r-><\/span>draw();\r\n\r\n delete<\/span> r;\r\n\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n \r\n}\r\n<\/pre>\n<\/div>\nRectangleAdapter<\/code> derived the interface from the Rectangle<\/code>, and the implementation for LegacyRectangle <\/code>using multiple inheritances. Additionally, RectangleAdapter<\/code> adapts the size of the LegacyRectangle<\/code> (line 1).<\/p>\n\n