c++新特性实验(2)类型特性

1. 基本类型

1.1 增加

long long long long int signed long long signed long long int unsigned long long unsigned long long int	至少 64 位的宽度	C++11
char8_t	UTF-8 字符类型	C++20
char16_t	UTF-16 字符类型	C++11
char32_t	UTF-32 字符类型	C++11

1.2 修改char的符号（C++14）

　　char 的符号取决于编译器和目标平台：

• ARM 和 PowerPC 的默认设置常为无符号，
• 而 x86 与 x64 的默认设置常为有符号。

1.3 示例

 #include <cstdlib>
 #include <cstdio>

 int
 main(int argc,char *argv[]){

     unsigned long long ull = ;
     unsigned long long int ulli = ;
     signed long long sll = ;
     signed long long int slli = ;

     long long ll = ;
     long long int lli = ;

     printf("unsigend long long = %ld \n",sizeof ++ull);
     printf("ull = %ld \n",ull);

     char16_t ch16 = u'\u5b89';
     char32_t ch32 = U'\u5353';
     printf("ch16 = %c ,char32 = %c \n",ch16,ch32);    

     return ;
 }

2.固定字节数的整形类型(C++11 起)

定义于头文件 <cstdint>

int8_t,int16_t,int32_t,int64_t	分别为宽度恰为 8、16、32 和 64 位的有符号整数类型
int_fast8_t,int_fast16_t,int_fast32_t,int_fast64_t,	分别为宽度至少有 8、16、32 和 64 位的最快的有符号整数类型
int_least8_t,int_least16_t,int_least32_t,int_least64_t	分别为宽度至少有 8、16、32 和 64 位的最小的有符号整数类型
intmax_t,uintmax_t	最大宽度的有符号整数类型和无符号整数类型
intptr_t,uintptr_t	足以保存指针的有符号整数类型和无符号整数类型
uint8_t,uint16_t,uint32_t,uint64_t	宽度恰为 8、16、32 和 64 位的无符号整数类型.
uint_fast8_t,uint_fast16_t,uint_fast32_t,uint_fast64_t	分别为宽度至少有 8、16、32 和 64 位的最快无符号整数类型
uint_least8_t,uint_least16_t,uint_least32_t,uint_least64_t	分别为宽度至少有 8、16、32 和 64 位的最小无符号整数类型

3.基本类型宏(C++11 起)

定义于头文件 <cstddef>

nullptr_t,nullptr	空指针字面量.	C++11
max_align_t	具有不小于任何基础类型的内存对齐需求的平凡类型	C++11
byte	字节类型 ,它在std::下。	C++17
__bool_true_false_are_defined	C 兼容用宏常量，展开成整数常量1	C++11
__alignas_is_defined	C 兼容用宏常量，展开成整数常量 1	C++11

4.类型特性(C++11 起)

类型特性用以查询或修改类型的属性,通常在模板中使用.

定义于头文件 <type_traits>

4.1 基础类型类别

is_void	检查类型是否为 void	C++11
is_null_pointer	检查类型是否为 std::nullptr_t	C++14
is_integral	检查类型是否为整型	C++11
is_floating_point	检查类型是否是浮点类型	C++11
is_array	检查类型是否是数组类型	C++11
is_enum	检查类型是否是枚举类型	C++11
is_union	检查类型是否为联合体类型	C++11
is_class	检查类型是否非联合类类型	C++11
is_function	检查是否为函数类型	C++11
is_pointer	检查类型是否为指针类型	C++11
is_lvalue_reference	检查类型是否为左值引用	C++11
is_rvalue_reference	检查类型是否为右值引用	C++11
is_member_object_pointer	检查类型是否为指向非静态成员对象的指针	C++11
is_member_function_pointer	检查类型是否为指向非静态成员函数的指针	C++11

4.2 复合类型类别

is_fundamental	检查是否是基础类型	C++11
is_arithmetic	检查类型是否为算术类型	C++11
is_scalar	检查类型是否为标量类型	C++11
is_object	检查是否是对象类型	C++11
is_compound	检查是否为复合类型	C++11
is_reference	检查类型是否为左值引用或右值引用	C++11
is_member_pointer	检查类型是否为指向非静态成员函数或对象的指针类型	C++11

4.3 类型属性、类型关系、受支持操作

参看：http://en.cppreference.com/w/cpp/types

4.4示例

 #include <type_traits>
 #include <cstddef>
 #include <cstdlib>
 #include <cstdio>
 #include <cstdint>

 using namespace std;

 class student{
 public:
     byte age;
 public:
     student(byte _age):age(_age){

     }
     student(){
         student((byte));
     }
 };

 template<typename T>
 void
 fun(T const &t){
     printf("\n-------==============------------=====-----------\n");
     printf("t = %d\n",t);
     printf("t.is_void = %d\n"           ,is_void<T>::value          );
     printf("t.is_integral = %d\n"       ,is_integral<T>::value      );
     printf("t.is_null_pointer = %d\n"   ,is_null_pointer<T>::value  );
     printf("t.is_pointer = %d\n"        ,is_pointer<T>::value       );
     printf("t.is_class = %d\n"          ,is_class<T>::value         );
     printf("t.is_lv_reference = %d\n"   ,is_lvalue_reference<T>::value);
     printf("t.is_array = %d\n"          ,is_array<T>::value);
     if(is_array<T>::value){
         printf("t.rank = %ld\n"         ,rank<T>::value);
     }
 }

 //template<typename U>
 void fun(nullptr_t null){
 }

 template<typename F, typename A>
 void
 funfwd(F _fun, A _arg)
 {
     _fun(_arg);
 }

 void
 g(int* i){
     printf("function g called \n");
 }

 int
 main(int argc,char *argv[]){
     byte age = (byte);
     int8_t int8[] = {,,,};
     int64_t int64 = , &refInt64 = int64;
     int_fast64_t *pFastInt64 = &int64;
     nullptr_t nullp;

     byte *pb = &age;
     student s = {age};
     printf("s.age = %d\n",s.age);

     fun();
     fun<student>(s);
     //fun<void>(1);
     fun(pFastInt64);
     fun(int8);
     fun(refInt64);
     fun(nullp);

     g(NULL);                // ok
     g();                   // ok
     funfwd(g, nullptr);     // ok
     //funfwd(g, NULL);      // error：NULL是个宏，值是0,这里展开后不存在函数 g(int)

     return ;
 }

4.5类型修改

remove_cv	从给定类型移除 const 或/与 volatile 限定符	C++11
remove_const
remove_volatile
add_cv	添加 const 或/与 volatile 限定符到给定类型	C++11
add_const
add_volatile
remove_reference	从给定类型移除或者添加引用	C++11
add_lvalue_reference add_rvalue_reference
remove_pointer	移除给定类型的一级指针	C++11
add_pointer	对给定类型添加一级指针	C++11

示例

 #include <cstdio>
 #include <cstdlib>
 #include <type_traits>

 using namespace std;

 template<typename T>
 void
 fun(const T &t){
     printf("t is const = %d\n",is_const<T>::value);

     typedef remove_cv<const int>::type type1;

 }

 int
 main(int argc,char *argv[]){

     const int a = ;
     fun();

     typedef remove_cv<const int>::type              type1;
     typedef remove_cv<volatile int>::type           type2;
     typedef remove_cv<const volatile int>::type     type3;
     typedef remove_cv<const volatile int*>::type    type4;
     typedef remove_cv<int * const volatile>::type   type5;

     printf("test1 : %s \n" ,(is_same<int, type1>::value ? "passed" : "failed" ));
     printf("test2 : %s \n" ,(is_same<int, type2>::value ? "passed" : "failed" ));
     printf("test3 : %s \n" ,(is_same<int, type2>::value ? "passed" : "failed" ));
     printf("test4 : %s \n" ,(is_same<const volatile int*, type4>::value ? "passed" : "failed" ));
     printf("test5 : %s \n" ,(is_same<int*, type5>::value ? "passed" : "failed" ));

     return ;
 }

5.字面类型(C++11 起)

5.1 哪些类型是字面类型

• 标量类型；
• 引用类型；
• 字面类型的数组；
• 可为 cv 限定的 void （从而 constexpr 函数能返回 void ）(C++14 起)；
• 可有 cv 限定的类类型，并拥有下列全部约束：

• • 拥有析构函数，
  • 满足以下条件之一

1. 1. 聚合类型
   2. 或拥有至少一个 constexpr 构造函数（可为模板）且非复制或移动构造函数
   3. 或为闭包类型 (C++17 起)

• • 对于联合体，至少有一个非静态数据成员是非 volatile 字面类型，
  • 对于非联合体，所有非静态数据成员和基类是非 volatile 字面类型。
  • 所有非静态数据成员和基类是非 volatile 字面类型。

5.2 示例

 #include <stdexcept>
 #include <cstdlib>
 #include <cstdio>

 using namespace std;

 class conststr{
 public:
     const char* p;
     size_t sz;
     template<size_t N>
     constexpr conststr(const char(&a)[N]) : p(a), sz(N - ) {}

     constexpr char operator[](size_t n) const {
         return n < sz ? p[n] : throw out_of_range("");
     }
     constexpr size_t size() const { return sz; }
 };

 constexpr size_t countlower(conststr s, size_t n = ,size_t c = ){
     return n == s.size() ? c : s[n] >= 'a' && s[n] <= 'z' ? countlower(s, n + , c + ) : countlower(s, n + , c);
 }

 // 要求编译时常量的输出函数，为测试用
 template<int n>
 struct constN{
     constN() {
         printf("n = %d \n",n);
     }
 };

 int
 main(int argc,char *argv[]){
     constN<countlower("Hello, world!")>(); // 隐式转换成 conststr
     return ;
 }