@@ -48,6 +48,8 @@
     1.  [exception](exception.cpp)
     1.  [typedef](typedef.cpp)
     1.  [typecast](typecast.cpp)
+        1.  [const_cast](const_cast.cpp)
+        1.  [static_cast](static_cast.cpp)
     1.  [new](new.cpp)
     1.  [Preprocessor](preprocessor.cpp)
     1.  using
 
@@ -27,6 +27,7 @@
 #include <new>
 #include <numeric> // partial sums, differences on std::vectors of numbers
 #include <ostream> // ostream
+#include <ratio> // ratio, nano
 #include <set> // multiset, set
 #include <string> // getline, string
 #include <sstream> // stringstream
 
@@ -0,0 +1,75 @@
+/*
+# const_cast
+
+    Change (add/remove) constantness and volatility of objects (property called cv-qualification).
+
+    Does not compile to any extra CPU instructions:
+    only changes type information for the compiler.
+
+    TODO when should it be used?
+
+    - http://stackoverflow.com/questions/357600/is-const-cast-safe/357640#357640
+    - avoiding repetition between const and non const versions of arguments is an use case:
+        - http://stackoverflow.com/questions/123758/how-do-i-remove-code-duplication-between-similar-const-and-non-const-member-func
+        - http://stackoverflow.com/questions/5324256/is-const-castconst-type-ever-useful/5326238#comment69750469_5326238
+*/
+
+#include "common.hpp"
+
+int main() {
+    // Remove const.
+    {
+        // UB if data is const.
+        {
+            const int i = 0;
+            const int *ip = &i;
+
+            // ERROR.
+            //*ip = 1;
+
+            // UB
+            // http://stackoverflow.com/questions/19208560/can-we-use-const-cast-to-modify-a-constant-variable
+            //*(const_cast<int*>(ip)) = 1;
+        }
+
+        // Fine otherwise.
+        {
+            int i = 0;
+            const int *ip = &i;
+
+            // ERROR.
+            //*ip = 1;
+
+            // OK.
+            *(const_cast<int*>(ip)) = 1;
+            assert(i == 1);
+        }
+    }
+
+    // Only works for references or pointers.
+    {
+        int i;
+        // ERROR
+        //const_cast<const int>(i);
+        const_cast<const int&>(i);
+        const_cast<const int*>(&i);
+    }
+
+    // ERROR: Returns rvalues. Therefore cannot initialize non-const references.
+    {
+        int i = 0;
+        int *ip;
+        //const int*& ipa = const_cast<const int*>(ip);
+        //ipa is a non const reference.
+        //int *const& would be a const reference.
+    }
+
+    // Only has effect for a single statement.
+    {
+        int i = 0;
+        const int *ip = &i;
+        const_cast<int*>(ip);
+        // ERROR.
+        //*ip = 1;
+    }
+}
@@ -1,23 +1,60 @@
 /*
 # chrono
+
+What the clocks map to in GCC Linux:
+http://stackoverflow.com/questions/12392278/measure-time-in-linux-time-vs-clock-vs-getrusage-vs-clock-gettime-vs-gettimeof
 */
 
 #include "common.hpp"
 
 int main() {
 #if __cplusplus >= 201103L
-    // TODO
+    // # period
     std::cout << "high_resolution_clock::period::den = " << std::chrono::high_resolution_clock::period::den << std::endl;
+    std::cout << "steady_clock::period::den          = " << std::chrono::steady_clock::period::den << std::endl;
+    std::cout << "system_clock::period::den          = " << std::chrono::system_clock::period::den << std::endl;
 
+    // high_resolution_clock
     // Wall clock: sleeps are counted.
-	std::chrono::high_resolution_clock::time_point start_time = std::chrono::high_resolution_clock::now();
-    std::this_thread::sleep_for(std::chrono::seconds(1));
-	std::chrono::high_resolution_clock::time_point end_time = std::chrono::high_resolution_clock::now();
-	auto dt = end_time - start_time;
-
-    std::cout << typeid(dt).name() << std::endl;
-    std::cout << std::chrono::duration_cast<std::chrono::nanoseconds>(dt).count() << std::endl;
-    std::cout << std::chrono::duration_cast<std::chrono::seconds>(dt).count() << std::endl;
+    {
+        std::chrono::high_resolution_clock::time_point start_time = std::chrono::high_resolution_clock::now();
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+        std::chrono::high_resolution_clock::time_point end_time = std::chrono::high_resolution_clock::now();
+        std::chrono::duration<double, std::nano> dt = end_time - start_time;
+        std::cout << "high_resolution_clock after sleep = " << std::chrono::duration_cast<std::chrono::nanoseconds>(dt).count() << std::endl;
+    }
+
+    // steady_clock
+    {
+        auto start_time = std::chrono::steady_clock::now();
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+        auto end_time = std::chrono::steady_clock::now();
+        auto dt = end_time - start_time;
+        std::cout << "steady_clock after sleep = " << std::chrono::duration_cast<std::chrono::nanoseconds>(dt).count() << std::endl;
+    }
+
+    // system_clock
+    {
+        auto start_time = std::chrono::system_clock::now();
+        std::this_thread::sleep_for(std::chrono::seconds(1));
+        auto end_time = std::chrono::system_clock::now();
+        auto dt = end_time - start_time;
+        std::cout << "system_clock after sleep = " << std::chrono::duration_cast<std::chrono::nanoseconds>(dt).count() << std::endl;
+    }
+
+    /*
+    # time_point
+
+    Convertions to base types:
+
+    - http://stackoverflow.com/questions/12835577/how-to-convert-stdchronotime-point-to-calendar-datetime-string-with-fraction
+    - http://stackoverflow.com/questions/33785564/how-do-i-get-seconds-since-epoch-as-a-double-given-a-time-point
+    - http://stackoverflow.com/questions/31255486/c-how-do-i-convert-a-stdchronotime-point-to-long-and-back
+    */
+    {
+        std::cout << "nanoseconds since system_clock epoch = " << std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::system_clock::now().time_since_epoch()).count() << std::endl;
+        std::cout << "nanoseconds since steady_clock epoch = " << std::chrono::duration_cast<std::chrono::nanoseconds>(std::chrono::steady_clock::now().time_since_epoch()).count() << std::endl;
+    }
 	return 0;
 #endif
 }
@@ -63,16 +63,6 @@ int main() {
             }
         }
 
-        // begin is overloaded by method const-ness, to return either
-        // ::iterator or ::const_iterator
-        // http://stackoverflow.com/questions/12646998/how-does-begin-know-which-return-type-to-return-const-or-non-const
-        {
-            const std::vector<std::unique_ptr<int>> v;
-            // ERROR.
-            //std::vector<std::unique_ptr<int>>::iterator it = v.begin();
-            std::vector<std::unique_ptr<int>>::const_iterator it = v.begin();
-        }
-
         /*
         # backwards iteration
 
@@ -286,7 +276,7 @@ int main() {
             int i;
             int is[] = {1, 2, 0};
 
-            //forward
+            // forward
             {
                 i = 2;
                 for (auto it = v.rbegin(); it != v.rend(); ++it) {
@@ -435,4 +425,39 @@ int main() {
                     == typeid(std::random_access_iterator_tag));
         }
     }
+
+    /*
+    # const_iterator
+
+        begin is overloaded by method const-ness, to return either
+        ::iterator or ::const_iterator
+
+        http://stackoverflow.com/questions/12646998/how-does-begin-know-which-return-type-to-return-const-or-non-const
+
+        const_iterator returns const values, so it cannot be used to modify the container.
+    */
+    {
+        // Basic example.
+        {
+            const std::vector<int> v{0};
+
+            // ERROR.
+            //std::vector<int>::iterator it = v.begin();
+
+            // OK.
+            std::vector<int>::const_iterator it = v.begin();
+            // ERROR: cannot modify because const_iterator.
+            //*it = 1;
+        }
+
+        // iterator can be converted to const_iterator.
+        {
+            std::vector<int> v{0};
+            std::vector<int>::iterator it = v.begin();
+            *it = 1;
+            std::vector<int>::const_iterator itc = it;
+            // ERROR.
+            //*itc = 1;
+        }
+    }
 }