现代c++语言核心特性解析

1新基础类型

1.1 longlong

long long 占64位 

通常表示方法为 

long long x = 65536LL;或者 long long x = 65536; ==>0x10000

这里LL为字面量后缀 若是没有LL  65536这个数会被当做32位数 若是<<16位的话 第二个x的值会得到0(因为超出了) 第一个x 得到0x100000000 

 long long 也可以用做枚举底层整形类型 

enum class LargeValue : long long {
    Value1 = 10000000000000000ULL,
    Value2,
    Value3
};
 

枚举 拓展 

template <typename T>
void process(T t) {
    std::cout << "General processing: " << t << std::endl;
}
// 针对 LogLevel 的模板特化
template <>
void process<LogLevel>(LogLevel level) {
    switch (level) {
    case LogLevel::Info:
        std::cout << "Information: ";
        break;
    case LogLevel::Warning:
        std::cout << "Warning: ";
        break;
    case LogLevel::Error:
        std::cout << "Error: ";
        break;
    }
    std::cout << "Log message processed" << std::endl;
}
int main() {
    // 调用通用模板函数
   process(42);  // 处理整数
   process("Hello");  // 处理字符串
   // 调用针对 LogLevel 的特化版本
   process(LogLevel::Info);    // 输出: Information: Log message processed
   process(LogLevel::Warning); // 输出: Warning: Log message processed
   process(LogLevel::Error);   // 输出: Error: Log message processed
}

更加详细的可以看[C++11] 枚举新特性完整解析_c++11 enum 明确-CSDN博客

1.2 char16_t 与char32_t

 ..........

2内联和嵌套命名空间

2.1内嵌命名空间

//相比与 直接在parent中定义函数 

namespace parent
{
    inline namespace child1{
        void mym1()
        {
            cout << "mymniubi" << endl;
        }
    }
    namespace child2
    {
        void hsf1()
        {
            cout << "HSF" << endl;
        }
    }
}

int main()
{
    parent::mym1();//可以不用child1 
    parent::hsf::hsf1();
}

namespace Parent 
{
  namespace V1 {
       void foo() { std::cout << "foo v1.0" << std::endl; }
               }
inline namespace V2 {
            void foo() { std::cout << "foo v2.0" << std::endl; }
                }
}
int main()
{
        Parent::foo();
}

一开始是1.0的版本 当要更新里边的东西的时候 可以内联 v2 当要用到V1的时候用parent::V1::foo  这样就可以不用改V1里边的东西

如果想加入V3版本的接口，则只需要创建V3的内联命名空间，并且将命名空间V2的inline关键字删除。请注意，示例代码中只能有一个内联命名空间，否则编译时会造成二义性问题，编译器不知道使用哪个内联命名空间的foo函数。

2.2 嵌套命名空间的简化语法
 

//C++17
namespace A::B::C {
    int foo() { return 5; }
}
//等价于
namespace A {
    namespace B {
        namespace C {
            int foo() { return 5; }
            }
       }
   }


//C++20
namespace A::B::inline C {
     int foo() { return 5; }
}
// 或者
namespace A::inline B::C {
    int foo() { return 5; }
}
//分别等价于
namespace A::B {
    inline namespace C {
        int foo() { return 5; }
        }
    }


namespace A {
    inline namespace B {
        namespace C {
            int foo() { return 5; }
                }
            }
        }