@@ -2,54 +2,6 @@
 
 #include "common.hpp"
 
-// TODO factor those dummy classes.
-class Class {};
-class Base {};
-class BaseProtected {};
-
-// ERROR: no compound literals in C++
-//void foo (int bar[] = (int[2]){0 ,1});
-
-// Function overloading
-
-    std::string overload(int i) { return "i"; }
-    std::string overload(float i) { return "f"; }
-    std::string overload(int i, int j) { return "ii"; }
-    std::string overload(float i, float j, float k = 0.f) { return "iff"; }
-
-    // OK even if return type is different all is decided at compile time.
-
-        //int overload(int i, int j, int k){return 1;}
-
-    // ERROR: conflict with int.
-
-        //void overload(const int i){}
-
-    // ERROR: cannot differentiate by output since output is used to decide if other parts of code make sense.
-
-        //int overload(){return 0;}
-        //float overload(){return 0.f;}
-
-    // ERROR: conflict with int int
-
-        //void overload(int i, int j=0){cout << "int int=";}
-
-    // BAD: compiles, but is useless to give a default,
-    // since when calling, caller is *forced* to give a value for j
-    // or wil get `call is ambiguous` compile time error
-    // because compiler cannot decide between
-    // here the default arg can be usefull for a call of type float float.
-
-        //void overload(float i, float j=1){cout << "float float=";}
-
-    // TODO: why does this compile, that is, how not to make an ambiguous call with overload(int).
-
-        void overloadValAddr(const int i) {}
-        void overloadValAddr(const int& i) {}
-
-    void overloadBase(Base b) {}
-    void overloadBase(BaseProtected b) {}
-
 // Default arguments.
 
     void defaultArgProto(int i=0);
@@ -73,7 +25,7 @@ int def_no_argname(int, int) { return 2; }
 # auto arguments
 */
 
-        /*ERROR: no you can't*/
+    /*ERROR: no you can't*/
     /*
     int func_auto(auto a){
         ++a;
@@ -82,58 +34,6 @@ int def_no_argname(int, int) { return 2; }
     */
 
 int main() {
-    // # Overload
-    {
-        assert(overload(1) == "i");
-
-        //base type conversions
-        {
-            assert(overload(1.0f) == "f");
-
-            /*
-            ERROR: ambiguous overload(int) overload(float)
-
-            Compiler does not know wether convert double to float or int.
-            */
-            //overload(1.0);
-        }
-
-        /*
-        ERROR: ambiguous
-        should compiler coverts to Base or BaseProtected? Both are possible via the default copy constructors.
-        */
-        {
-            Class cOverload;
-            //overloadBase(cOverload);
-        }
-
-        // ERROR: ambiguous
-        //i=4;
-        //overloadValAddr(i);
-
-        /*
-        # volatile overload
-
-            Functions that differ by `volatile` can be overloaded:
-
-            - http://stackoverflow.com/questions/10242578/volatile-overloading
-        */
-        {}
-
-        /*
-        Function pointer: decided by the typecast.
-
-        http://stackoverflow.com/questions/2942426/how-to-specify-a-pointer-to-an-overloaded-function
-        */
-        {
-            // Variable.
-            {
-                std::string (*fi)(int) = overload;
-                std::string (*ff)(float) = overload;
-            }
-        }
-    }
-
     /*
     In C++, unlike in C, definitions can omit argument names if they don't use those arguments!
 
 
@@ -57,13 +57,22 @@ int main() {
             std::vector<int> v{1, 2, 0};
             int i = 0;
             int is[]{1, 2, 0};
-
             for (auto it = v.begin(); it != v.end(); ++it) {
                 assert(*it == is[i]);
                 ++i;
             }
         }
 
+        // 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
 
@@ -95,6 +104,7 @@ int main() {
         }
     }
 
+#if __cplusplus >= 201103L
     /*
     # range based for loop
 
@@ -121,9 +131,73 @@ int main() {
         - operator++()
         - operator!=()
         - operator*()
+
+        Those methods are usually trivial, except for ++ which can actually
+        make a smart choice of what is the next value.
+        I bet http://www.boost.org/doc/libs/1_62_0/libs/iterator/doc/index.html
+        will make implementation easier with some defaults.
     */
     {
-#if __cplusplus >= 201103L
+        // Implement it yourself.
+        {
+            class Iterable {
+                private:
+                    class Iterator {
+                        public:
+                            Iterator(int *ip) : ip(ip) {}
+                            Iterator& operator++() {
+                                this->ip++;
+                                return *this;
+                            }
+                            bool operator!=(const Iterator& other) const {
+                                return this->ip != other.ip;
+                            }
+                            // cont& could be used if there is no backing data,
+                            int& operator*() const {
+                                return *this->ip;
+                            }
+                        private:
+                            int *ip;
+                    };
+                public:
+                    Iterable() : is{1, 2, 3} {
+                    }
+                    Iterator begin() {
+                        return Iterator(&is[0]);
+                    }
+                    Iterator end() {
+                        return Iterator(&is[3]);
+                    }
+                private:
+                    int is[3];
+            };
+
+            // Range based for loop works with that bare skelleton.
+            // Try removing any method of the above, and watch it blow up.
+            {
+                int sum = 0;
+                Iterable it;
+                for (auto const& x : it) {
+                    sum += x;
+                }
+                assert(sum == 6);
+            }
+
+            // Modification is also possible with this
+            // default-ish setup and references.
+            {
+                int sum = 0;
+                Iterable it;
+                for (auto& x : it) {
+                    x++;
+                }
+                for (auto& x : it) {
+                    sum += x;
+                }
+                assert(sum == 9);
+            }
+        }
+
         //forward
         {
             // If `int&` is used, no useless copies are made.
@@ -268,8 +342,9 @@ int main() {
         // Last element.
         *(v.end() - 1);
 
+        // POSSIBLE RUNTIME ERROR.
         // After last element no born check.
-        *(v.end());
+        //*(v.end());
 
         // No such method.
         //(v.end().hasNext());
 
@@ -23,9 +23,9 @@
 
     Member or not
 
-        Certain operators can be both member functions and free functions.
+        Certain operators can be both member functions and free overloaded functions.
         This includes most operators such as `+`, `=`, `+=` and others.
-        See: <http://stackoverflow.com/a/4421729/895245> for a discussion on how to decide
+        See: http://stackoverflow.com/a/4421729/895245 for a discussion on how to decide
         between them.
 
         One question is that being non member improves the incapsulation, since then those
@@ -112,12 +112,13 @@ class OperatorOverload {
 
 
             // Prefix. Should return reference to match primitives.
-            const OperatorOverload& operator++() {
+            OperatorOverload& operator++() {
                 ++(this->i);
                 return *this;
             }
 
             // Postfix. Should not return reference to match primitives.
+            // Yes, this weird `int` dummy argument differentiates signature from prefix.
             const OperatorOverload operator++(int) {
                 OperatorOverload old(*this);
                 ++(*this);
@@ -329,16 +330,36 @@ int main() {
         {
             // Prefix
             {
-                OperatorOverload i(1);
-                assert(++i == OperatorOverload(2));
-                assert(i == OperatorOverload(2));
+                {
+                    OperatorOverload i(1);
+                    assert(++i == OperatorOverload(2));
+                    assert(i == OperatorOverload(2));
+                }
+
+                // The non-const reference return allows to chain ++.
+                {
+                    OperatorOverload i(1);
+                    assert(++(++i) == OperatorOverload(3));
+                    assert(i == OperatorOverload(3));
+
+                    // Just like for primitives.
+                    {
+                        int i = 0;
+                        assert(++(++i) == 2);
+                        assert(i == 2);
+                    }
+                }
             }
 
             // Postfix. TODO
             {
                 OperatorOverload i(1);
                 assert(i++ == OperatorOverload(1));
                 assert(i == OperatorOverload(2));
+
+                // ERROR. Cannot chain postfix, just like for primitives.
+                // It must return a new value.
+                //(i++)++
             }
         }