深入理解C++11【3】

【深入理解C++11【3】】

1、POD类型

　　Plain Old Data. Plain 表示了POD是个普通的类型。C++11将POD划分为两个基本概念的合集：

　　1）平凡的（trivial）

　　2）标准布局的（standard layout）

　　一个平凡的类或结构体应该符合以下定义：

　　1）拥有平凡的默认构造函数（trivial constructor）和析构函数（trivial destructor）。

　　　　平凡的默认构造函数就是说构造函数“ 什么都不干”。通常情况下，不定义类的构造函数，编译器就会为我们生成一个平凡的默认构造函数。而一旦定义了构造函数，即使构造函数不包含参数，函数体里也没有任何的代码，那么该构造函数也不再是“ 平凡” 的。

　　2）拥有平凡的拷贝构造函数（trivial copy constructor）和移动构造函数（trivial move constructor）。

　　3）拥有平凡的拷贝赋值运算符（trivial assignmnt operator）和移动赋值运算符（trivial move operator）。

　　4）不能包含虚函数以及虚基类。

　　C++11中可以使用 is_trivial struct来判定一个类型是否是 trivial。

　　类模板 is_ trivial 的成员 value 可以用于判断 T 的类型是否是一个平凡的类型。除了类和结构体外， is_ trivial 还可以对内置的标量类型数据（比如 int、 float 都属于平凡类型）及数组类型（元素是平凡类型的数组总是平凡的）进行判断。

template < typename T> struct std:: is_ trivial;

　　标准布局应该符合以下定义：

　　1）所有非静态成员有相同的访问权限。

　　2）在类或结构体继承时，满足以下两种情况之一：

　　　　a）派生类中有非静态成员，且只有一个仅包含静态成员的基类。

　　　　b）基类有非静态成员，而派生类没有非静态成员。

struct B1 { static int a; }; 
struct D1 : B1 { int d; }; 
struct B2 { int a; }; 
struct D2 : B2 { static int d; }; 
struct D3 : B2, B1 { static int d; }; 
struct D4 : B2 { int d; }; 
struct D5 : B2, D1 { };

　　　　D1、 D2 和 D3 都是标准布局的，而 D4 和 D5 则不属于标准布局的。

　　　　非静态成员只要同时出现在派生类和基类间，其即不属于标准布局的。而多重继承也会导致类型布局的一些变化，所以一旦非静态成员出现在多个基

　　3）类中第一个非静态成员的类型与其基类不同。

struct A : B{ B b; }; // 不是标准布局
struct C : B{int a; B b;} // 是标准布局

　　4）没有虚函数和虚基类。

　　5）所有非静态数据成员均符合标准布局类型，其基类也符合标准布局。这是一个递归的定义，没有什么好特别解释的。

　　C++11中可以使用struct模板 is_standard_layout 来判断是否是标准布局类型。

template < typename T> struct std:: is_ standard_ layout;

　　要判定一个类型是否是 POD，可以使用 is_pod模板：

template < typename T> struct std:: is_ pod;

　　使用 POD 有什么好处呢？我们看得到的大概有如下 3 点：

　　1）字节赋值。memset、memcpy。

　　2）与C内存布局兼容。

　　3）保证了静态初始化的安全有效。

2、非受限联合体

　　C++98中 union不能包含非POD类型。也不允许union拥有静态或引用类型的成员。

　　在新的 C++ 11 标准中，取消了联合体对于数据成员类型的限制。标准规定，任何非引用类型都可以成为联合体的数据成员，这样的联合体即所谓的非受限联合体（ Unrestricted Union）。

　　非受限联合体有一个非 POD 的成员，而该非 POD 成员类型拥有有非平凡的构造函数，那么非受限联合体成员的默认构造函数将被编译器删除。如下：

#include < string> 
using namespace std; 

union T { 
    string s; // string 有 非 平凡 的 构造 函数 
    int n; 
}; 

int main() { 
    T t; // 构造 失败， 因为 T 的 构造 函数 被 删除 了 
} // 编译 选项: g++ -std= c++ 11 3- 7- 4. cpp

　　解决这个问题的办法是，由程序员自己为非受限联合体定义构造函数。placement new将会发挥很好的作用。

#include < string> 
using namespace std; 
union T { 
    string s; 
    int n; 
    public: // 自定义 构造 函数 和 析 构 函数 
        T(){ new (&s) string; } 
        ~ T() { s.~ string(); } 
}; 

int main() { 
    T t; // 构造 析 构成 功 
} // 编译 选项: g++ -std= c++ 11 3- 7- 5. cpp

　　匿名非受限联合体可以运用于类的声明中。

3、用户自定义字面量 — 后缀标识操作符

struct RGBA{ 
    uint8 r; 
    uint8 g; 
    uint8 b; 
    uint8 a; 
    RGBA( uint8 R, uint8 G, uint8 B, uint8 A = 0): r( R), g( G), b( B), a( A){} 
}; 

RGBA operator "" _C( const char* col, size_ t n) 
{ 
    // 一个 长度 为 n 的 字符串 col 
    const char* p = col; 
    const char* end = col + n; 
    const char* r, *g, *b, *a; 
    r = g = b = a = nullptr; 
    for(; p != end; ++ p) { 
        if (*p == 'r') 
            r = p; 
        else if (*p == 'g') g = p;
        else if (*p == 'b') b = p; 
        else if (*p == 'a') a = p; 
    } 
    if ((r == nullptr) || (g == nullptr) || (b == nullptr)) 
        throw; 
    else if (a == nullptr) 
        return RGBA( atoi( r+ 1), atoi( g+ 1), atoi( b+ 1)); 
    else 
        return RGBA( atoi( r+ 1), atoi( g+ 1), atoi( b+ 1), atoi( b+ 1)); 
}

　　除去字符串外，后缀声明也可以作用于数值，比如，用户可能使用 60W、 120W 的表示方式来标识功率，用 50kg 来表示质量，用 1200N 来表示力等。

struct Watt{ unsigned int v; }; 

Watt operator "" _w( unsigned long long v) { 
    return {(unsigned int) v}; 
} 

int main() { 
    Watt capacity = 1024_ w; 
} // 编译 选项: g++ -std= c++ 11 3- 8- 3. cpp

　　C++11中跟字面量“类型”密切相关的规则有以下四条：

　　1）如果字面量为整型数，那么字面量操作符函数只可接受 unsigned long long 或者 const char* 为其参数。

　　2）如果字面量为浮点型数，则字面量操作符函数只可接受 long double 或者 const char* 为参数。

　　3）如果字面量为字符串，则字面量操作符函数函数只可接受 const char*, size_ t 为参数（已知长度的字符串）。

　　4）如果字面量为字符，则字面量操作符函数只可接受一个 char 为参数。

　　另外有以下几点要注意：

　　1）operator"" 与用户自定义后缀之间必须有空格。

　　2）后缀建议以下划线开始。不宜使用非下划线后缀的用户自定义字符串常量，否则会被编译器警告。

4、内联名字空间

　　namespace中的namespace会带来一个问题，如parentspace::childspace，外部使用者调用childspace内的内容的，会比较麻烦，因为需要需要前缀 parentspace::childspace，是否能让外部使用者不需要知道childspace的存在？

　　C++98 中可以在parentspace中使用 using namespace child; 来解决，但是存在模板特化的问题。C++ 98 标准不允许在不同的名字空间中对模板进行特化。如下：

namespace Jim { 
    namespace Basic { 
        struct Knife{ 
            Knife() { 
                cout << "Knife in Basic." << endl; 
            } 
        }; 
        class CorkScrew{}; 
    } 
    
    namespace Toolkit{ 
        template< typename T> 
        class SwissArmyKnife{}; 
    }
    
    // ... 
    namespace Other{ 
        // ... 
    } 
    
    // 打开 一些 内部 名字 空间 
    using namespace Basic; 
    using namespace Toolkit; 
} 

// LiLei 决定 对 该 class 进行 特 化 
namespace Jim { 
    template<> class SwissArmyKnife< Knife>{}; // 编译 失败 
} 

using namespace Jim; 

int main() 
{ 
    SwissArmyKnife< Knife> sknife; 
} // 编译 选项: g++ 3- 9- 2. cpp

View Code

　　在 C++ 11 中，标准引入了一个新特性，叫做“ 内联的名字空间”。通过关键字“ inline namespace” 就可以声明一个内联的名字空间。内联的名字空间允许程序员在父名字空间定义或特化子名字空间的模板。

namespace Jim { 
    inline namespace Basic { 
        struct Knife{ 
            Knife() { 
                cout << "Knife in Basic." << endl; 
            } 
        }; 
        class CorkScrew{}; 
    } 
    
    inline namespace Toolkit{ 
        template< typename T> 
        class SwissArmyKnife{}; 
    } 
    
    // ... 
    namespace Other{ 
        Knife b; // Knife in Basic 
        struct Knife{ Knife() { cout << "Knife in Other" << endl;} }; 
        Knife c; // Knife in Other 
        Basic:: Knife k; // Knife in Basic

    } 
    
    // 打开 一些 内部 名字 空间 
    using namespace Basic; 
    using namespace Toolkit; 
} 

// LiLei 决定 对 该 class 进行 特 化 
namespace Jim { 
    template<> class SwissArmyKnife< Knife>{}; // 编译 通过
} 

using namespace Jim; 

int main() 
{ 
    SwissArmyKnife< Knife> sknife; 
} // 编译 选项: g++ 3- 9- 2. cpp

View Code

　　上面对 inline namespace 的用法是一种误用，上述用法跟将 childspace中的内容放到 parentspace没有区别。inline namespace正确的用法是用于版本管理。如：

namespace Jim { 
#if __cplusplus == 201103L 
    inline 
#endif 
    namespace cpp11{ 
        struct Knife{ Knife() { cout << "Knife in c++ 11." << endl; } }; 
        // ... 
    } 
    
#if __cplusplus < 201103L 
    inline 
#endif 
    namespace oldcpp{ 
        struct Knife{ Knife() { cout << "Knife in old c++." << endl; } }; 
        // ... 
    } 
} 

using namespace Jim; 
int main() { 
    Knife a; // Knife in c++ 11. (默认 版本) 
    cpp11:: Knife b; // Knife in c++ 11. (强制 使用 cpp11 版本) 
    oldcpp:: Knife c; // Knife in old c++. (强制 使用 oldcpp11 版本) 
} // 编译 选项: g++ -std= c++ 11 3- 9- 4. cpp

View Code

　　所谓“ 参数关联名称查找”，即 ADL（ Argument- Dependent name Lookup）。这个特性允许编译器在名字空间内找不到函数名称的时候，在参数的名字空间内查找函数名字。

namespace ns_ adl{ 
    struct A{}; 
    void ADLFunc( A a){} // ADLFunc 定义 在 namespace ns_ adl 中 
} 

int main() { 
    ns_ adl:: A a; 
    ADLFunc( a); // ADLFunc 无需 声明 名字 空间 
}

5、模板的别名。

　　C++98中只有typedef可以定义类型的别名，C++11中using也可以定义类型的别名。

#include < iostream> 
#include < type_ traits> 
using namespace std; 
using uint = unsigned int; 
typedef unsigned int UINT; 
using sint = int; 

int main() 
{
    cout << is_ same< uint, UINT>:: value << endl; // 1 
} 
// 编译 选项: g++ -std= c++ 11 3- 10- 1. cpp

　　不止于此，C++11中using 还可以结合模板使用。

template< typename T> using MapString = std:: map< T, char*>; 
MapString< int> numberedString;

6、SFINEA，Substitution failure is not an error.

　　对重载的模板的参数进行展开的时候，如果展开导致了一些类型不匹配，编译器并不会报错。如下：

struct Test { 
    typedef int foo; 
}; 

template < typename T> 
void f( typename T:: foo) {} // 第一个 模板 定义 - #1 

template < typename T> 
void f( T) {} // 第二个 模板 定义 - #2 

int main() 
{
    f< Test>( 10); // 调用# 1. 
    f< int>( 10); // 调用# 2. 由于 SFINEA， 虽然 不存在 类型 int:: foo， 也不 会 发生 编译 错误 
} 
// 编译 选项： g++ 2- 14- 1. cpp

7、右尖括号的改进

　　在 C++ 98 中，有一条需要程序员规避的规则：如果在实例化模板的时候出现了连续的两个右尖括号>，那么它们之间需要一个空格来进行分隔，以避免发生编译时的错误。

template < int i> 
class X{}; 

template < class T> 
class Y{}; 

Y< X< 1> > x1; // 编译 成功 
Y< X< 2>> x2; // 编译 失败 

// 编译 选项: g++ -c 4- 1- 1. cpp

　　上面代码，在 x2 的定义中，编译器会把>> 优先解析为右移符号。除去上面这个例子，在使用 *_cast 时也会有同样的问题。如：

const vector< int> v = static_cast< vector< int>>( v); //无法 通过 编译

　　C++11中，这种限制被取消了。

8、auto

int main() 
{ 
    double foo(); 
    auto x = 1; // x 的 类型 为 int 
    auto y = foo(); // y 的 类型 为 double
    struct m { int i; } str; 
    auto str1 = str; // str1 的 类型 是 struct m 
    auto z; // 无法 推导， 无法 通过 编译 
    z = x; 
} 
// 编译 选项: g++ -std= c++ 11 4- 2- 2. cpp

　　在类型自定义类型转换情形中，auto 能够帮上大忙：

class PI { 
public: 
    double operator* (float v) { 
        return (double) val * v; // 这里 精度 被 扩展 了 
    } 
        
    const float val = 3. 1415927f; 
}; 

int main() 
{ 
    float radius = 1. 7e10; 
    PI pi; 
    auto circumference = 2 * (pi * radius); 
} 
// 编译 选项: g++ -std= c++ 11 4- 2- 5. cpp

　　auto的另一特性是自适应：

　　1）假设上述代码 PI 的作者改动了 PI 的定义，比如将 operator* 返回值变为 long double，此时， main 函数并不需要修改，因为 auto 会“ 自适应” 新的类型。

　　2）对于不同的平台上的代码维护， auto 也会带来一些“ 泛型” 的好处。这里我们以 strlen 函数为例，在 32 位的编译环境下， strlen 返回的为一个 4 字节的整型，而在 64 位的编译环境下， strlen 会返回一个 8 字节的整型。

　 3）当 auto 应用于模板的定义中，其“ 自适应” 性会得到更加充分的体现。如下：

template< typename T1, typename T2> 
double Sum( T1 & t1, T2 & t2) 
{ 
    auto s = t1 + t2; // s 的 类型 会在 模板 实例 化 时 被 推导 出来 
    return s; 
} 

int main() 
{ 
    int a = 3; 
    long b = 5; 
    float c = 1. 0f, d = 2. 3f; 
    auto e = Sum< int ,long>( a, b); // s 的 类型 被 推导 为 long 
    auto f = Sum< float, float>( c, d); // s 的 类型 被 推导 为 float 
} 
// 编译 选项: g++ -std= c++ 11 4- 2- 7. cpp

　　auto 可以提升性能：

#define Max1( a, b) ((a) > (b)) ? (a) : (b) 
#define Max2( a, b) ({  
    auto _a = (a);  
    auto _b = (b);  
    (_a > _b) ? _a: _b; }) 
    
int main() 
{ 
    int m1 = Max1( 1* 2* 3* 4, 5+ 6+ 7+ 8); 
    int m2 = Max2( 1* 2* 3* 4, 5+ 6+ 7+ 8); 
} 
// 编译 选项: g++ -std= c++ 11 4- 2- 8. cpp

　　前者采用传统的三元运算符表达式，这可能会带来一定的性能问题。因为 a 或者 b 在三元运算符中都出现了两次，

9、auto的使用细则

　　实际上对于 a、 c、 d 三个变量而言，声明其为 auto* 或 auto 并没有区别。而如果要使得 auto 声明的变量是另一个变量的引用，则必须使用 auto&。

int x; 
int * y = &x; 
double foo(); 
int & bar(); 

auto * a = &x; // int* 
auto & b = x; // int& 
auto c = y; // int* 
auto * d = y; // int* 

auto * e = &foo(); // 编译 失败, 指针 不能 指向 一个 临时 变量 
auto & f = foo(); // 编译 失败, nonconst 的 左 值 引用 不能 和 一个 临时 变量 绑 定 
auto g = bar(); // int 
auto & h = bar(); // int& 

// 编译 选项: g++ -std= c++ 11 4- 2- 9. cpp

　　声明为 auto 的变量并不能从其初始化表达式中“ 带走” cv 限制符。

double foo(); 
float * bar(); 

const auto a = foo(); // a: const double 
const auto & b = foo(); // b: const double& 
volatile auto * c = bar(); // c: volatile float* 

auto d = a; // d: double 
auto & e = a; // e: const double & 
auto f = c; // f: float * 

volatile auto & g = c; // g: volatile float * & 

// 编译 选项: g++ -std= c++ 11 4- 2- 10. cpp

　　上述代码中，通过 auto 声明的变量 d、 f 却无法带走 a 和 f 的常量性或者易失性。这里的例外还是引用，可以看出，声明为引用的变量 e、 g 都保持了其引用的对象相同的属性（

　　用 auto 来声明多个变量类型时，只有第一个变量用于 auto 的类型推导。注意 const auto *：

auto x = 1, y = 2; // x 和 y 的 类型 均为 int 

// m 是一 个 指向 const int 类型 变量 的 指针, n 是 一个 int 类型 的 变量 
const auto* m = &x, n = 1; auto i = 1, j = 3. 14f; // 编译 失败

auto o = 1, &p = o, *q = &p; // 从左 向右 推导 

// 编译 选项: g++ -std= c++ 11 4- 2- 11. cpp -c

　　C++ 11 新引入的初始化列表，以及 new，都可以使用 auto 关键字

#include < initializer_ list> 
auto x = 1; 
auto x1( 1); 
auto y {1}; // 使用 初始化 列表 的 
auto auto z = new auto( 1); // 可以 用于 new 

// 编译 选项: g++ -std= c++ 11 -c 4- 2- 12. cpp

　　禁止使用 auto 的情形：

　　1）auto不能是函数形参。

　　2）非静态成员变量的类型不能是auto。

　　3）不能声明 auto 数组。

　　4）不能在模板参数中使用 auto。

#include < vector> 
using namespace std; 
void fun( auto x = 1){} // 1: auto 函数 参数， 无法 通过 编译 

struct str{ 
    auto var = 10; // 2: auto 非 静态 成员 变量， 无法 通过 编译 
}; 

int main() { 
    char x[ 3]; 
    auto y = x; 
    auto z[ 3] = x; // 3: auto 数组， 无法 通过 编译 
    // 4: auto 模板 参数（ 实例 化 时）， 无法 通过 编译 
    vector< auto> v = {1}; 
} 

// 编译 选项: g++ -std= c++ 11 4- 2- 13. cpp

10、typeid 与 decltype

　　C++ 98 对动态类型支持就是 C++ 中的运行时类型识别（ RTTI）。

　　RTTI 的机制是为每个类型产生一个 type_info 类型的数据，程序员可以在程序中使用 typeid 随时查询一个变量的类型， typeid 就会返回变量相应的 type_info 数据。而 type_info 的 name 成员函数可以返回类型的名字。

　　而在 C++ 11 中，又增加了 hash_code 这个成员函数，返回该类型唯一的哈希值，以供程序员对变量的类型随时进行比较。

#include < iostream> 
#include < typeinfo> 
using namespace std; 

class White{}; 
class Black{}; 

int main() 
{ 
    White a; 
    Black b; 
    cout << typeid( a). name() << endl; // 5White 
    cout << typeid( b). name() << endl; // 5Black 
    White c; 
    bool a_ b_ sametype = (typeid( a). hash_ code() == typeid( b). hash_ code()); 
    bool a_ c_ sametype = (typeid( a). hash_ code() == typeid( c). hash_ code()); 
    cout << "Same type? " << endl; cout << "A and B? " << (int) a_ b_ sametype << endl; // 0 
    cout << "A and C? " << (int) a_ c_ sametype << endl; // 1 
} 

// 编译 选项: g++ -std= c++ 11 4- 3- 1. cpp

View Code

　　上面代码中，5 这样的前缀是 g++ 这类编译器输出的名字，其他编译器可能会打印出其他的名字，这个标准并没有明确规定），

　　由于 RTTI 会带来一些运行时的开销，所以一些编译器会让用户选择性地关闭该特性（比如 XL C/ C++ 编译器的- qnortti， GCC 的选项- fno- rttion，或者微软编译器选项/ GR-）。

　　decltype 总是以一个普通的表达式为参数，返回该表达式的类型。decltype的demo：

int main() 
{ 
    int i; 
    decltype( i) j = 0; 
    cout << typeid( j). name() << endl; // 打 印出" i", g++ 表示 int 
    float a; 
    double b; 
    decltype( a + b) c; 
    cout << typeid( c). name() << endl; // 打 印出" d", g++ 表示 double 
} 
// 编译 选项: g++ -std= c++ 11 4- 3- 2. cpp

View Code

11、decltype的应用

　　decltype 与 typedef/using 的全用：

using size_ t = decltype( sizeof( 0)); 
using ptrdiff_ t = decltype(( int*) 0 - (int*) 0); 
using nullptr_ t = decltype( nullptr);

　　decltype 可以用于获取匿名类型的类型。这是C++98所做不到的。

enum class{ K1, K2, K3} anon_ e; // 匿名 的 强 类型 枚举 

union { 
    decltype( anon_ e) key; 
    char* name; 
}anon_ u; // 匿名 的 union 联合体 

struct { 
    int d; 
    decltype( anon_ u) id; 
}anon_ s[ 100]; // 匿名 的 struct 数组 

int main() { 
    decltype( anon_ s) as; 
    as[ 0]. id. key = decltype( anon_ e):: K1; // 引用 匿名 强 类型 枚举 中的 值 
} 

// 编译 选项: g++ -std= c++ 11 4- 3- 4. cpp

　　与模板特化结合：

template< typename T1, typename T2> 

void Sum( T1 & t1, T2 & t2, decltype( t1 + t2) & s) 
{ 
    s = t1 + t2; 
} 

void Sum( int a[], int b[], int c[])
{ 
    // 数组 版本 
} 

int main() 
{ 
    int a[ 5], b[ 5], c[ 5]; 
    Sum( a, b, c); // 选择 数组 版本 
    int d, e, f; 
    Sum( d, e, f); // 选择 模板 的 实例 化 版本 
} 
// 编译 选项: g++ -std= c++ 11 4- 3- 6. cpp

　　decltype 只能接受表达式做参数，像函数名做参数的表达式 decltype( hash) 是无法通过编译的。

int hash( char*); 
map< char*, decltype( hash)> dict_ key; // 无法 通过 编译 
map< char*, decltype( hash( nullptr))> dict_ key1;

　　std::result_of 可以用于推导函数返回值类型：

typedef double (*func)(); 
int main() 
{ 
    result_ of< func()>:: type f; // 由 func() 推导 其 结果 类型 
} 
// 编译 选项: g++ -std= c++ 11 4- 3- 8. cpp

11、decltype 推导四规则

　　decltype 可以带双括号。如下：

int i; 
decltype( i) a; // a: 
int decltype(( i)) b; // b: int &, 无法 编译 通过

　　推导四规则如下：

　　1）最常见的情形，如前文所应用。如果 e 是一个 没有带括号的标记符表达式（ id- expression）或者 类成员访问表达式，那么 decltype( e) 就是 e 所命名的实体的类型。此外，如果 e 是一个 被重载的函数，则会导致编译时错误。

　　2）否则，假设 e 的类型是 T，如果 e 是一个将亡值( xvalue)，那么 decltype( e) 为 T&&。

　　3）否则，假设 e 的类型是 T，如果 e 是一个左值，则 decltype( e) 为 T&。

　　4）否则，假设 e 的类型是 T，则 decltype( e) 为 T。

int i = 4; 
int arr[ 5] = {0}; 
int *ptr = arr;

struct S { double d; } s; 
void Overloaded( int); 
void Overloaded( char); // 重载 的 函数 
int && RvalRef(); 
const bool Func( int); 

// 规则 1: 单个 标记 符 表达式 以及 访问 类 成员， 推导 为本 类型 
decltype( arr) var1; // int[ 5], 标记 符 表达式 
decltype( ptr) var2; // int*, 标记 符 表达式 
decltype( s. d) var4; // double, 成员 访问 表达式 
decltype( Overloaded) var5; // 无法 通过 编译， 是个 重载 的 函数 

// 规则 2: 将 亡 值， 推导 为 类型 的 右 值 引用 
decltype( RvalRef()) var6 = 1; // int&& 

// 规则 3: 左 值， 推导 为 类型 的 引用 
decltype( true ? i : i) var7 = i; // int&, 三元 运算符， 这里 返回 一个 i 的 左 值 
decltype(( i)) var8 = i; // int&, 带 圆括号 的 左 值 
decltype(++ i) var9 = i; // int&, ++ i 返回 i 的 左 值 
decltype( arr[ 3]) var10 = i; // int& []操作 返回 左 值 
decltype(* ptr) var11 = i; // int& *操作 返回 左 值 
decltype(" lval") var12 = "lval"; // const char(&)[ 9], 字符串 字面 常量 为 左 值 

// 规则 4： 以上 都不 是， 推导 为本 类型 
decltype( 1) var13; // int, 除 字符串 外 字面 常量 为 右 值 
decltype( i++) var14; // int, i++ 返回 右 值 
decltype(( Func( 1))) var15; // const bool, 圆括号 可以 忽略

View Code

　　可以使用 is_rvalue_reference、is_lvalue_reference 来判断是否是左右值引用。

#include < type_ traits> 
#include < iostream> 
using namespace std; 
int i = 4; 
int arr[ 5] = {0}; 
int *ptr = arr; 
int && RvalRef(); 
int main()
{ 
    cout << is_ rvalue_ reference< decltype( RvalRef())>:: value << endl; // 1 
    cout << is_ lvalue_ reference< decltype( true ? i : i)>:: value << endl; // 1 
    cout << is_ lvalue_ reference< decltype(( i))>:: value << endl; // 1 
    cout << is_ lvalue_ reference< decltype(++ i)>:: value << endl; // 1 
    cout << is_ lvalue_ reference< decltype( arr[ 3])>:: value << endl; // 1 
    cout << is_ lvalue_ reference< decltype(* ptr)>:: value << endl; // 1 
    cout << is_ lvalue_ reference< decltype(" lval")>:: value << endl; // 1 
    cout << is_ lvalue_ reference< decltype( i++)>:: value << endl; // 0 
    cout << is_ rvalue_ reference< decltype( i++)>:: value << endl; // 0 
}

12、cv限制符的继承与冗余符号

　　与 auto 类型推导时不能“ 带走” cv 限制符不同， decltype 是能够“ 带走” 表达式的 cv 限制符的。通过 is_const、is_volatile 可以判定 const、volatile 性。

using namespace std; 
const int ic = 0; 
volatile int iv; 
struct S { int i; }; 
const S a = {0}; 
volatile S b; 
volatile S* p = &b; 
int main() 
{ 
    cout << is_ const< decltype( ic)>:: value << endl; // 1 
    cout << is_ volatile< decltype( iv)>:: value << endl; // 1 
    cout << is_ const< decltype( a)>:: value << endl; // 1 
    cout << is_ volatile< decltype( b)>:: value << endl; // 1 
    cout << is_ const< decltype( a. i)>:: value << endl; // 0, 成员 不是 const 
    cout << is_ volatile< decltype( p-> i)>:: value << endl; // 0, 成员 不是 volatile 
}

　　进行类型定义时，也会允许一些冗余的符号。比如 cv 限制符以及引用，符号&，通常情况下，如果推导出的类型已经有了这些属性，冗余的符号则会被忽略。

int i = 1; 
int & j = i; 
int * p = &i; 
const int k = 1; 
int main() 
{ 
    decltype( i) & var1 = i; 
    decltype( j) & var2 = i; // 冗余 的&, 被 忽略 
    cout << is_ lvalue_ reference< decltype( var1)>:: value << endl;// 1, 是 左 值 引用 
    cout << is_ rvalue_ reference< decltype( var2)>:: value << endl;// 0, 不是 右 值 引用 
    cout << is_ lvalue_ reference< decltype( var2)>:: value << endl;// 1, 是 左 值 引用 
    decltype( p)* var3 = &i; // 无法 通过 编译 
    decltype( p)* var3 = &p; // var3 的 类型 是 int**
    auto* v3 = p; // v3 的 类型 是 
    int* v3 = &i; 
    const decltype( k) var4 = 1; // 冗余 的 const， 被 忽略 
}

　　这里特别要注意的是 decltype( p)* 的情况。可以看到，在定义 var3 变量的时候，由于 p 的类型是 int*，因此 var3 被定义为了 int** 类型。这跟 auto 声明中，* 也可以是冗余的不同。在 decltype 后的* 号，并不会被编译器忽略。

13、追踪返回类型的引入

　　C++ 11 引入新语法— 追踪返回类型。

template< typename T1, typename T2> 
auto Sum( T1 & t1, T2 & t2) -> decltype( t1 + t2)
{ 
    return t1 + t2;
}

　　我们把函数的返回值移至参数声明之后，复合符号-> decltype( t1+ t2) 被称为追踪返回类型。而原本函数返回值的位置由 auto 关键字占据。这样，我们就可以让编译器来推导 Sum 函数模板的返回类型了。而 auto 占位符和-> return_ type 也就是构成追踪返回类型函数的两个基本元素。

14、使用追踪返回类型的函数

　　使用追踪返回类型的时候，可以不必写明作用域。如下，InnerType不必写明其作用域。

class OuterType
{ 
    struct InnerType { int i; }; 
    InnerType GetInner(); 
    InnerType it; 
}; 
// 可以 不 写 OuterType:: InnerType 
auto OuterType:: GetInner() -> InnerType { return it; }

　　返回类型后置，使模板中的一些类型推导就成为了可能。如下：

template< typename T1, typename T2> 
auto Sum( const T1 & t1, const T2 & t2) -> decltype( t1 + t2)
{ 
    return t1 + t2; 
} 

template < typename T1, typename T2> 
auto Mul( const T1 & t1, const T2 & t2) -> decltype( t1 * t2)
{ 
    return t1 * t2; 
} 

int main() 
{ 
    auto a = 3; 
    auto b = 4L; 
    auto pi = 3. 14; 
    auto c = Mul( Sum( a, b), pi); 
    cout << c << endl; // 21. 98 
}

　　追踪返回类型的另一个优势是简化函数的定义，提高代码的可读性。

#include < type_ traits> 
#include < iostream> 
using namespace std; 

// 有的 时候， 你会 发现 这是 面试 题 
int (*(*pf())())() { return nullptr; } 

// auto (*)() -> int(*) () 一个 返回 函数 指针 的 函数( 假设 为 a 函数) 
// auto pf1() -> auto (*)() -> int (*)() 一个 返回 a 函数 的 指针 的 函数 
auto pf1() -> auto (*)() -> int (*)() { return nullptr; } 

int main() 
{ 
    cout << is_ same< decltype( pf), decltype( pf1)>:: value << endl; // 1 
}

　　使用追踪返回类型，可以实现参数和返回类型不同时的转发。

double foo( int a) 
{ 
    return (double) a + 0. 1; 
} 

int foo( double b) 
{ 
    return (int) b; 
} 

template < class T> 
auto Forward( T t) -> decltype( foo( t))
{ 
    return foo( t); 
} 

int main()
{ 
    cout << Forward( 2) << endl; // 2. 1 
    cout << Forward( 0. 5) << endl; // 0 
}

　　以下内容是等价的。

auto (*fp)() -> int;
int (*fp)();

auto (&fr)()->int;
int (&fr)();

15、

16、

17、