Changes between Version 19 and Version 20 of BestPracticeHandbook

Timestamp:

May 11, 2015, 9:59:15 PM (7 years ago)

Author:

Niall Douglas

Comment:

--

BestPracticeHandbook

@@ -720 +720 @@
 todo
 
-== 15. DESIGN: Consider making (more) use of C++ 11 namespace composure as a design pattern ==
-
-todo check this compiles
-
-https://en.wikipedia.org/wiki/Policy-based_design
-
-{{{
+== 15. DESIGN: Consider making (more) use of ADL C++ namespace composure as a design pattern ==
+
+Most C++ programmers are aware of C++ template policy based design. This example is taken from https://en.wikipedia.org/wiki/Policy-based_design:
+
+{{{#!c++
 #include <iostream>
 #include <string>
@@ -790 +788 @@
 }}}
 
+This works very well when your policy implementations fit nicely into template types, however for when they don't an ADL based namespace composure design pattern can be highly effective. Here is the same program written using namespace composure:
+
+{{{#!c++
+#include <iostream>
+#include <string>
+
+template<typename MessageType>
+void print(MessageType const &message)
+{
+  std::cout << message << std::endl;
+}
+namespace HelloWorld
+{
+  template<class T> void run(T v)
+  {
+    print(message(v));  // Can't instantiate message nor print until T is known
+  }
+}
+namespace LanguagePolicyEnglish
+{
+  struct tag {};
+  template<class T> std::string message(T)
+  {
+    return "Hello, World!";
+  }
+}
+namespace LanguagePolicyGerman
+{
+  struct tag {};
+  template<class T> std::string message(T)
+  {
+    return "Hallo Welt!";
+  }
+}
+namespace LanguagePolicyDefault
+{
+  struct tag {};
+  using LanguagePolicyGerman::message;
+}
+int main()
+{
+  /* Example 1 */
+  {
+    using namespace LanguagePolicyEnglish;
+    using namespace HelloWorld;
+    run(tag()); // prints "Hello, World!"
+    // This works because HelloWorld::run()'s message() resolves inside these
+    // braces to LanguagePolicyEnglish::message() to the same namespace as
+    // struct tag thanks to argument dependent lookup
+  }
+
+  /* Example 2
+  * Does the same, but uses another language policy */
+  {
+    using namespace LanguagePolicyGerman;
+    using namespace HelloWorld;
+    run(tag()); // prints "Hallo Welt!"
+    // Whereas HelloWorld::run()'s message() now resolves inside these
+    // braces to LanguagePolicyGerman::message()
+  }
+
+  /* Example 3 */
+  {
+    using namespace LanguagePolicyDefault;
+    using namespace HelloWorld;
+    run(tag()); // prints "Hallo Welt!"
+    // Tries to find message() inside namespace LanguagePolicyDefault,
+    // which finds message aliased to LanguagePolicyGerman::message()
+  }
+}
+}}}
+
+The above pattern is in fact entirely C++ 03 code and uses no C++ 11. However, template aliasing in C++ 11 makes the above pattern much more flexible. Have a look at https://github.com/ptal/expected/blob/master/include/boost/functional/monads/rebindable.hpp for examples of this ADL invoked namespace composure design pattern
+
 == 16. BUILD: Consider defaulting to header only, but make available C++ 11 features very substantially reducing build times ==