@@ -45,6 +45,7 @@
                 1.  [Static constructor for private members](static_constructor_private.cpp)
             1.  [POD](pod.cpp)
         1.  Inheritance
+            1.  [`override` identifier](override.cpp)
             1.  [Inheritance override](inheritance_override.cpp)
             1.  [Inherit overload_hide](inherit_overload_hide.cpp)
             1.  [Inheriting constructor](inheriting_constructor.cpp)
 
@@ -1,3 +1,5 @@
+// Let's learn how method name resolution works with inheritance.
+
 #include "common.hpp"
 
 class B {
@@ -44,17 +46,21 @@ int main() {
     assert(c.B::i   == 1);
     assert(cp->B::i == 1);
 
+#if 0
     // ERROR: ambiguous because on multiple base classes.
-    //c.iAmbiguous = 0;
+    c.iAmbiguous = 0;
+#endif
     c.B::iAmbiguous = 0;
 
     // Analogous for methods.
     callStack.clear();
     assert(c.f() == 2);
     assert(c.B::f() == 0);
 
+#if 0
     // ERROR ambiguous.
-    //c.fAmbiguous();
+    c.fAmbiguous();
+#endif
     assert(c.B::fAmbiguous() == 0);
     assert(c.B2::fAmbiguous() == 1);
 }
@@ -0,0 +1,45 @@
+// https://stackoverflow.com/questions/13880205/is-the-override-keyword-just-a-check-for-a-overridden-virtual-method/54535784#54535784
+// https://stackoverflow.com/questions/29145476/requiring-virtual-function-overrides-to-use-override-keyword
+
+#include "common.hpp"
+
+struct Base {
+    virtual void f() = 0;
+    virtual void g() = 0;
+    virtual void h(int) = 0;
+    void i() {}
+};
+
+struct Derived : Base {
+    void f() override;
+    void g() override {};
+
+    void h(int) {};
+#if 1
+    void h(float) {};
+#else
+    // g++6.4.0: error: ‘void Derived::h(float)’ marked ‘override’, but does not override
+    void h(float) override {};
+#endif
+
+#if 1
+    void i() {}
+#else
+    // g++6.4.0: error: ‘void Derived::i()’ marked ‘override’, but does not override
+    void i() override {}
+#endif
+};
+
+#if 1
+void Derived::f() {}
+#else
+// g++6.4.0: error: virt-specifiers in ‘f’ not allowed outside a class definition
+void Derived::f() override {}
+#endif
+
+int main() {
+    Derived derived;
+
+    // Yup, it is a valid identifier in normal contexts.
+    int override = 1;
+}