![\"patterns\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/06\/patterns.png\")
<\/p>\nThe Proxy Pattern is probably the most influential design pattern for C++. The Proxy provides a placeholder for accessing another object.<\/p>\n
<\/p>\n
<\/p>\n
<\/p>\n
The proxy pattern is one of the seven structural patterns from the book “Design Patterns: Elements of Reusable Object-Oriented Software”<\/a>. A proxy controls access to another object, allowing you to perform additional operations before or after you access the original object. Sound familiar?<\/p>\n Which idiom is characteristic of C++? Right: RAII (R<\/strong>esource A<\/strong>cquisition I<\/strong>s I<\/strong>nitialization). RAII is the C++ way to implement the Proxy Pattern. Here are the facts about the Proxy Pattern.<\/p>\n The following examples use two generic proxies: <\/p>\n <\/p>\n Both smart pointers can transparently access the member function The smart pointers model the Proxy Pattern in C++. Additionally, the RAII Idiom is the C++ adaption of the Proxy Pattern. RAII is the crucial idiom in C++. I will write more about it in a few lines.<\/p>\n RAII stands for R<\/strong>esource A<\/strong>cquisition I<\/strong>s I<\/strong>nitialization. The most crucial idiom in C++ is that a resource should be acquired in the constructor and released in the object’s destructor. The key idea is that the destructor will automatically be called if the object goes out of scope. Or, to put it differently: A resource’s lifetime is bound to a local variable’s lifetime, and C++ automatically manages the lifetime of locals.<\/strong><\/p>\n There is one big difference between the Proxy Pattern and the RAII Idiom in C++. In the classical Proxy Pattern, the Proxy and the RealObject (object) implement the same interface. Therefore, you invoke a member function on the proxy, and this call is delegated to the object. On the contrary, it is typical for RAII to do the operation on the object implicitly.<\/p>\n The following example shows the deterministic behavior of RAII in C++.<\/p>\n <\/p>\n <\/p>\n ResourceGuard<\/span> is a guard that manages its resource. In this case, the string stands for the resource. ResourceGuard<\/span> creates in its constructor the resource and releases the resource in its destructor. It does its job very decent.<\/p>\n The destructor of resGuard1<\/span> (line 1) is called at the end of the <\/span>Proxy 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
\n
<\/span>Structure<\/span><\/h3>\n
![\"Proxy\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/11\/Proxy.png\")
<\/p>\n<\/span> <\/span><\/h3>\n
Proxy<\/strong><\/code><\/p>\n\n
RealSubject<\/code><\/li>\nRealSubject<\/code><\/li>\n<\/ul>\nSubject<\/code><\/strong><\/p>\n\n
Proxy<\/code> and the RealSubject<\/code><\/li>\n<\/ul>\nRealSubject<\/code><\/strong><\/p>\n\n
<\/span>Example<\/span><\/h3>\n
std::unique_ptr<\/code> and std::shared_ptr<\/code>.<\/p>\n\n\/\/ proxy.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <memory><\/span>\r\n\r\nclass<\/span> MyInt<\/span>{\r\n public:<\/span>\r\n MyInt(int<\/span> i):<\/span>i_(i){}\r\n int<\/span> getValue() const<\/span> {\r\n return<\/span> i_;\r\n }\r\n private:<\/span>\r\n int<\/span> i_;\r\n};\r\n\r\nint<\/span> main<\/span>(){\r\n\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n MyInt*<\/span> myInt =<\/span> new<\/span> MyInt(1998<\/span>); \/\/ (3)<\/span>\r\n std::<\/span>cout <<<\/span> \"myInt->getValue(): \"<\/span> <<<\/span> myInt-><\/span>getValue() <<<\/span> '\\n'<\/span>;\r\n\r\n std::<\/span>unique_ptr<<\/span>MyInt><\/span> uniquePtr{new<\/span> MyInt(1998<\/span>)}; \/\/ (1)<\/span>\r\n std::<\/span>cout <<<\/span> \"uniquePtr->getValue(): \"<\/span> <<<\/span> uniquePtr-><\/span>getValue() <<<\/span> '\\n'<\/span>;\r\n\r\n std::<\/span>shared_ptr<<\/span>MyInt><\/span> sharedPtr{new<\/span> MyInt(1998<\/span>)}; \/\/ (2)<\/span>\r\n std::<\/span>cout <<<\/span> \"sharedPtr->getValue(): \"<\/span> <<<\/span> sharedPtr-><\/span>getValue() <<<\/span> '\\n'<\/span>;\r\n\r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n}\r\n<\/pre>\n<\/div>\n getValue<\/code> of MyInt<\/code>. It makes no difference if you call the member function getValue<\/code> on the std::unique_ptr<\/code>, (line 1) on the std::shared_ptr<\/code>, (line 2), or on the object directly. All calls return the same value:<\/p>\n![\"proxy\"](\"https:\/\/www.modernescpp.com\/wp-content\/uploads\/2022\/11\/proxy_.png\")
<\/p>\n<\/span>Known Uses<\/span><\/h3>\n
<\/span>Related Patterns<\/span><\/h3>\n
\n
<\/span>Pros and Cons<\/span><\/h3>\n
Pros<\/h4>\n
\n
Cons<\/h4>\n
\n
<\/span>RAII Idiom<\/span><\/h2>\n
\n\/\/ raii.cpp<\/span>\r\n\r\n#include <iostream><\/span>\r\n#include <new><\/span>\r\n#include <string><\/span>\r\n\r\nclass<\/span> ResourceGuard<\/span>{\r\n private:<\/span>\r\n const<\/span> std::<\/span>string resource;\r\n public:<\/span>\r\n ResourceGuard(const<\/span> std::<\/span>string&<\/span> res):<\/span>resource(res){\r\n std::<\/span>cout <<<\/span> \"Acquire the \"<\/span> <<<\/span> resource <<<\/span> \".\"<\/span> <<<\/span> '\\n'<\/span>;\r\n }\r\n ~<\/span>ResourceGuard(){\r\n std::<\/span>cout <<<\/span> \"Release the \"<\/span><<<\/span> resource <<<\/span> \".\"<\/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 ResourceGuard resGuard1{\"memoryBlock1\"<\/span>}; \/\/ (1)<\/span><\/em>\r\n\r\n std::<\/span>cout <<<\/span> \"<\/span>\\n<\/span>Before local scope\"<\/span> <<<\/span> '\\n'<\/span>;\r\n {\r\n ResourceGuard resGuard2{\"memoryBlock2\"<\/span>}; \/\/ (3)<\/span><\/em>\r\n } \/\/ (4)<\/span><\/em>\r\n std::<\/span>cout <<<\/span> \"After local scope\"<\/span> <<<\/span> '\\n'<\/span>;\r\n \r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n std::<\/span>cout <<<\/span> \"<\/span>\\n<\/span>Before try-catch block\"<\/span> <<<\/span> '\\n'<\/span>;\r\n try{\r\n ResourceGuard resGuard3{\"memoryBlock3\"<\/span>};\r\n throw<\/span> std::<\/span>bad_alloc(); \/\/ (5)<\/span><\/em>\r\n } \r\n catch<\/span> (std::<\/span>bad_alloc&<\/span> e){ \/\/ (6)<\/span><\/em>\r\n std::<\/span>cout <<<\/span> e.what();\r\n }\r\n std::<\/span>cout <<<\/span> \"<\/span>\\n<\/span>After try-catch block\"<\/span> <<<\/span> '\\n'<\/span>;\r\n \r\n std::<\/span>cout <<<\/span> '\\n'<\/span>;\r\n\r\n} \/\/ (2)\r\n<\/span><\/em><\/pre>\n<\/div>\n