@@ -14,7 +14,7 @@ O               ?= 0
 STD             ?= c11
 PEDANTIC        ?= -pedantic-errors
 CFLAGS          ?= -g$(G) -O$(O) -pthread -std=$(STD) -Wextra $(PEDANTIC) $(CFLAGS_EXTRA)   #-pg 
-MYCXXFLAGS      ?= -g$(G) -O$(O) -pthread -std=c++11  -Wextra $(PEDANTIC) $(CXXFLAGS_EXTRA) #-pg 
+MYCXXFLAGS      ?= -g$(G) -O$(O) -pthread -std=c++14  -Wextra $(PEDANTIC) $(CXXFLAGS_EXTRA) #-pg 
 
 LIBS            ?= -lm -lrt #-lGL -lGLU -lglut
 
 
@@ -9,6 +9,7 @@
     1.  [Hello world](hello_world.cpp)
     1.  [goto crosses initialization of](goto-cross-initialization.cpp)
     1.  [const](const.cpp)
+    1.  [enum](enum.cpp)
     1.  [RTTI](rtti.md)
     1.  Compile time magic
         1.  [constexpr](constexpr.cpp)
 
@@ -0,0 +1,39 @@
+/*
+Simple rule: always use C++11 enum class, never the old C-style enums.
+
+- http://stackoverflow.com/questions/18335861/why-is-enum-class-preferred-over-plain-enum
+- http://stackoverflow.com/questions/4506750/how-do-i-use-the-enum-value-from-a-class-in-another-part-of-code
+- http://stackoverflow.com/questions/10869790/best-practices-for-enum-in-c
+*/
+
+#include "common.hpp"
+
+int main() {
+    // Unlike C, already does typedef, no need to write enum all the time.
+    {
+        enum E {A, B, C};
+        E e = A;
+    }
+
+#if __cplusplus >= 201103L
+    // Set storage size.
+    {
+        enum E : char {A, B, C};
+        assert(sizeof(E) == sizeof(char));
+    }
+
+    // # class enum
+    enum class ClassEnum {
+        A,
+        B
+    };
+
+    // Error. YES, namespaces!
+    //ClassEnum classEnum = A;
+
+    ClassEnum classEnum = ClassEnum::A;
+
+    // No conversion insanity.
+    //int i = ClassEnum::A;
+#endif
+}
@@ -213,23 +213,6 @@ int main() {
         }
     }
 
-    // # enum
-    {
-        // Unlike C, already does typedef, no need to write enum all the time.
-        {
-            enum E {A, B, C};
-            E e = A;
-        }
-
-#if __cplusplus >= 201103L
-        // Set storage size.
-        {
-            enum E : char {A, B, C};
-            assert(sizeof(E) == sizeof(char));
-        }
-#endif
-    }
-
     // # for
     {
 
 
@@ -106,6 +106,7 @@ int main() {
         // They have the same address.
         {
             int i = 0;
+            //int& ia = i;
             int& ia = i;
             ia = 1;
             assert(i == 1);
 
@@ -34,9 +34,9 @@ int main() {
     {
         int i, i1;
         int& ia = i;
-        assert(typeid(i)   == typeid(int) );
-        assert(typeid(ia)  == typeid(int&));
-        assert(typeid(i)   == typeid(i1)  );
+        assert(typeid(i)  == typeid(int) );
+        assert(typeid(ia) == typeid(int&));
+        assert(typeid(i)  == typeid(i1)  );
     }
 
     // Works differently for virtual and non virtual classes!
 
@@ -8,6 +8,12 @@ Sample use case:
 - how to prevent memory leaks?
 
 http://en.cppreference.com/w/cpp/memory/unique_ptr
+
+unique_ptr may incur an extra dereferece cost, but it is usually well worth it.
+
+In Java, everything can be though as a smart pointer (shared),
+so using this is still more efficient than Java, since C++ can know the exact
+lifetime of objects, and release them immediately when they are done.
 */
 
 #include "common.hpp"
@@ -52,6 +58,12 @@ void manual_ptr_test() {
     }
 }
 
+// Create unique pointer dynamically,
+// and transfers ownershipt to caller.
+std::unique_ptr<Base> return_unique_ptr() {
+    return std::unique_ptr<Base>(new Base(1));
+}
+
 int main() {
     /* Basic example. */
     assert(Base::count == 0);
@@ -120,13 +132,46 @@ int main() {
     /*
     # unique_ptr function argments
 
-    - `std::move` for transfering ownership
+    -   transfering ownership TODO
+        -   use raw pointeres on the interface, and convert it to unique_ptr inside callee
+            -   if you already have an unique_ptr, release() it
+            -   this allows you to not tie down to a specific smart pointer on the function interface
+        -   use unique_ptr on interface and move on caller.
+            - Advantage: unique_ptr on interface documents ownership transfer,
+                and prevents callee from passing non new pointer to it by mistake.
     - TODO for not transfering ownership:
-        - `const &`
+        - `const & std::unique_ptr<T>`
         - `get()`. Simple and efficient. But how to use it for containers like `vector<std::unique_ptr>`?
+        - `T&` on function, `*t` on caller. Looks good!
 
-    http://stackoverflow.com/questions/8114276/how-do-i-pass-a-unique-ptr-argument-to-a-constructor-or-a-functionhttp://stackoverflow.com/questions/8114276/how-do-i-pass-a-unique-ptr-argument-to-a-constructor-or-a-function
+    - http://stackoverflow.com/questions/8114276/how-do-i-pass-a-unique-ptr-argument-to-a-constructor-or-a-functionhttp://stackoverflow.com/questions/8114276/how-do-i-pass-a-unique-ptr-argument-to-a-constructor-or-a-function
+    - http://stackoverflow.com/questions/11277249/how-to-pass-stdunique-ptr-around
     */
     {
     }
+
+    // Return unique_ptr from function.
+    {
+        {
+            Base::count = 0;
+            auto base = return_unique_ptr();
+            assert(Base::count == 1);
+            assert(base->i == 1);
+        }
+        assert(Base::count == 0);
+    }
+
+#if __cplusplus >= 201402L
+    // # make_unique
+    // Does new and puts it inside unique_ptr. Very convenient.
+    {
+        {
+            Base::count = 0;
+            auto base = std::make_unique<Base>(1);
+            assert(Base::count == 1);
+            assert(base->i == 1);
+        }
+        assert(Base::count == 0);
+    }
+#endif
 }
Original file line number	Diff line number	Diff line change
`@@ -106,6 +106,7 @@ int main() {`
`106`	`106`	`// They have the same address.`
`107`	`107`	`{`
`108`	`108`	`int i = 0;`
	`109`	`+ //int& ia = i;`
`109`	`110`	`int& ia = i;`
`110`	`111`	`ia = 1;`
`111`	`112`	`assert(i == 1);`
Original file line number	Diff line number	Diff line change
`@@ -34,9 +34,9 @@ int main() {`
`34`	`34`	`{`
`35`	`35`	`int i, i1;`
`36`	`36`	`int& ia = i;`
`37`		`- assert(typeid(i) == typeid(int) );`
`38`		`- assert(typeid(ia) == typeid(int&));`
`39`		`- assert(typeid(i) == typeid(i1) );`
	`37`	`+ assert(typeid(i) == typeid(int) );`
	`38`	`+ assert(typeid(ia) == typeid(int&));`
	`39`	`+ assert(typeid(i) == typeid(i1) );`
`40`	`40`	`}`
`41`	`41`
`42`	`42`	`// Works differently for virtual and non virtual classes!`