[TOC] ## 委托构造 ``` #include <iostream> class Base { public: int value1; int value2; Base() { value1 = 1; } Base(int val):Base() { value2 = val; } }; int main() { Base b; std::cout << b.value1; // output: 1 } ``` ## 继承构造 ``` #include <iostream> class Base { public: int value1; int value2; Base() { value1 = 2; } Base(int val):Base() { value2 = val; } }; class SubBase: public Base { public: using Base::Base; }; int main() { SubBase b; std::cout << b.value1; // 1 } ``` ## 显式虚函数重载 override ``` struct Base { virtual void foo(int); }; struct SubClass: Base { virtual void foo(int) override; // 合法 virtual void foo(float) override; // 非法, 父类没有此虚函数 }; ``` final ``` struct Base { virtual void foo() final; }; struct SubClass1 final : Base { }; // 合法 // // struct SubClass2 : SubClass1 { // }; // 非法, SubClass1 已 final // // struct SubClass3 : Base { // void foo(); // 非法, foo 已 final // }; ``` ## 强类型枚举 在传统 C++中，枚举类型并非类型安全，枚举类型会被视作整数，则会让两种完全不同的枚举类型可以进行直接的比较（虽然编译器给出了检查，但并非所有） ``` #include <iostream> #include <vector> enum class ENUM:unsigned int { V1=1, V2=2, V3=2, }; // 也用 cout 输出枚举值 template<typename T> std::ostream& operator<<( typename std::enable_if<std::is_enum<T>::value, std::ostream>::type& stream, const T& e) { return stream << static_cast<typename std::underlying_type<T>::type>(e); } int main() { if (ENUM::V1==ENUM::V2) { std::cout << "true"; }else { std::cout << "false"; } //也可以通过 cout 输出枚举值 std::cout << ENUM::V3; // 2 } ```