深入理解C++11

【深入理解C++11】

1、很多现实的编译器都支持 C99 标准 中的__ func__ 预定义标识符功能，其基本功能就是返回所在函数的名字。

　　编译器会隐式地在函数的定义之后定义__ func__ 标识符。

const char* hello() 
{ 
    static const char* __func__ = "hello";
    return __func__; 
}

　　__func__ 可以用于构造函数中。

#include < iostream> 
using namespace std; 

struct TestStruct { 
　　TestStruct () : name(__ func__) {} 
　　const char *name; 
}; 

int main() 
{ 
　　TestStruct ts; 
　　cout << ts. name << endl; // TestStruct 
} // 编译 选项: g++ -std= c++ 11 2- 1- 3. cpp

　　不过将__ fun__ 标识符作为 函数参数的默认值 是 不允许 的，

void FuncFail( string func_ name = __func__) {};// 无法 通过 编译

2、在 C99 标准中，程序员可以使用 变长参数的宏定义。变长参数的宏定义是指在宏定义中参数列表的最后一个参数为省略号，而预定义宏__ VA_ ARGS__ 则可以在宏定义的实现部分替换省略号所代表的字符串。

#define PR(...) printf(__ VA_ ARGS__)

　　一个应用的例子。

#include < stdio. h> 

#define LOG(...) { 
　　fprintf( stderr,"% s: Line %d: t", __FILE__, __LINE__); 
　　fprintf( stderr, __VA_ ARGS__); 
　　fprintf( stderr," n"); 
} 

int main() { 
　　int x = 3; // 一些 代码... 
　　LOG(" x = %d", x); // 2- 1- 5. cpp: Line 12: x = 3 
} 
// 编译 选项: g++ -std= c++ 11 2- 1- 5. cpp

3、long long 是C99标准。C++11中才将其定为正式标准。事实上，在C++11以前，很多编译器也支持了long long。

　　long long 整型有两种： long long 和 unsigned long long。在 C++ 11 中，标准要求 long long 整型可以在不同平台上有不同的长度，但至少有 64 位。

　　我们在写常数字面量时，可以使用 LL 后缀（或是 ll）标识一个 long long 类型的字面量，而 ULL（或 ull、 Ull、 uLL）表示一个 unsigned long long 类型的字面量。

long long int lli = -9000000000000000000LL; 
unsigned long long int ulli = -9000000000000000000ULL;

　　下面的类型是等价的： long long、 signed long long、 long long int、 signed long long int；而 unsigned long long 和 unsigned long long int 也是等价的。

　　对于 printf 函数来说，输出有符号的 long long 类型变量可以用符号% lld，而无符号的 unsigned long long 则可以采用% llu。

4、__cplusplus

　　比如在 C++ 03 标准中，__ cplusplus 的值被预定为 199711L，而在 C++ 11 标准中，宏__ cplusplus 被预定义为 201103L。

　　这点变化可以为代码所用。比如程序员在想确定代码是使用支持 C++ 11 编译器进行编译时，那么可以按下面的方法进行检测：

#if __cplusplus < 201103L #error "should use C++ 11 implementation" #endif

5、assert，运行时检查

　　在 C++ 中，标准在< cassert> 或< assert. h> 头文件中为程序员提供了 assert 宏，用于在运行时进行断言。

　　在 C++ 中，程序员也可以定义宏 NDEBUG 来禁用 assert 宏。这对发布程序来说还是必要的。

#ifdef NDEBUG 
    # define assert( expr) (static_ cast< void> (0)) 
#else 
    ... 
#endif

　　可以看到，一旦定义了 NDBUG 宏， assert 宏将被展开为一条无意义的 C 语句（通常会被编译器优化掉）。

6、static_assert，静态检查。

　　c++11中引入了static_assert。在过去，需要自己手动实现，或使用boost提供的功能 BOOST_STATIC_ASSERT。一个可能的手动实现如下：

#define assert_ static( e)  
    do {  
    enum { assert_ static__ = 1/( e) };  
} while (0)

　　一个使用样例如下：

static_ assert( sizeof( int) == 8, "This 64- bit machine should follow this!"); 
int main() 
{
     return 0; 
}

　　static_ assert 的断言表达式的结果必须是在编译时期可以计算的表达式，即必须是常量表达式。如果读者使用了变量，则会导致错误，

int positive( const int n) 
{
    static_ assert( n > 0, "value must > 0"); 
} // 编译 选项: g++ -std= c++ 11 -c 2- 5- 6. cpp

7、noexcept

　　在 excpt_ func 函数声明之后，我们定义了一个动态异常声明 throw( int, double)，该声明指出了 excpt_ func 可能抛出的异常的类型。事实上，该特性很少被使用，因此在 C++ 11 中被弃用了（参见附录 B），而表示函数不会抛出异常的动态异常声明 throw() 也被新的 noexcept 异常声明所取代。

　　以下的语法已被抛弃：

void excpt_ func() throw( int, double) { ... }

　　noexcept 的用法：

void excpt_ func() noexcept (常量 表达式);

　　下面的第二个 noexcept 就是一个 noexcept 操作符。当其参数是一个有可能抛出异常的表达式的时候，其返回值为 false，反之为 true。

template < class T> void fun() noexcept( noexcept( T())) {}

　　C++ 11 标准中让类的 析构函数默认也是 noexcept( true) 的。当然，如果程序员显式地为析构函数指定了 noexcept，或者类的基类或成员有 noexcept( false) 的析构函数，析构函数就不会再保持默认值。

#include < iostream> using namespace std; 
struct A { ~ A() { throw 1; } }; 
struct B { ~ B() noexcept( false) { throw 2; } }; 
struct C { B b; }; 
int funA() { A a; } 
int funB() { B b; } 
int funC() { C c; } 
int main() { 
　　try { funB(); } catch(...){ cout << "caught funB." << endl; // caught funB. } 
　　try { funC(); } catch(...){ cout << "caught funC." << endl; // caught funC. } 
　　try { funA(); // terminate called after throwing an instance of 'int' } catch(...){ cout << "caught funA." << endl; } } // 编译 选项: g++ -std= c++ 11 2- 6- 2. cpp

　　无论是析构函数声明为 noexcept( false) 的类 B，还是包含了 B 类型成员的类 C，其析构函数都是可以抛出异常的。只有什么都没有声明的类 A，其析构函数被默认为 noexcept( true)，从而阻止了异常的扩散。

8、在 C++ 98 中，支持了在类声明中使用等号“=” 加初始值的方式，来初始化类中 静态成员常量。这种声明方式我们也称之为“ 就地” 声明。就地声明在代码编写时非常便利，不过 C++ 98 对类中就地声明的要求却非常高。如果静态成员不满足常量性，则不可以就地声明，而且即使常量的静态成员也只能是整型或者 枚举型 才能就地初始化。而非静态成员变量的初始化则必须在构造函数中进行。

class Init{ 
    public: Init(): a( 0){} 
    Init( int d): a( d){} 
private: 
    int a; 
    const static int b = 0;
    int c = 1; // 成员， 无法 通过 编译 
    static int d = 0; // 成员， 无法 通过 编译 
    static const double e = 1. 3; // 非 整型 或者 枚举， 无法 通过 编译     
    static const char * const f = "e"; // 非 整型 或者 枚举， 无法 通过 编译 
}; // 编译 选项: g++ -c 2- 7- 1. cpp

　　使用 g++ 的读者可能发现就地初始化 double 类型静态常量 e 是可以通过编译的，不过这实际是 GNU 对 C++ 的一个扩展，并不遵从 C++ 标准）。

　　在 C++ 11 中，标准还允许使用等号= 或者花括号{} 进行就地的非静态成员变量初始化。

struct init{ int a = 1; double b {1. 2}; };

　　就地初始化 和初始化列表并不冲突。程序员可以为同一成员变量既声明就地的列表初始化，又在初始化列表中进行初始化，只不过初始化列表总是看起来“ 后作用于” 非静态成员。也就是说，初始化列表的效果总是优先于就地初始化的。

#include < string> using namespace std; 
class Mem { public: Mem( int i): m( i){} private: int m; }; 

class Group { 
　public: 
　　Group(){} // 这里 就不 需要 初始化 data、 mem、 name 成员 了 
　　Group( int a): data( a) {} // 这里 就不 需要 初始化 mem、 name 成员 了 
　　Group( Mem m) : mem( m) {} // 这里 就不 需要 初始化 data、 name 成员 了 
　　Group( int a, Mem m, string n): data( a), mem( m), name( n){} 
　private: 
　　int data = 1; 
　　Mem mem{ 0}; 
　　string name{" Group"}; 
}; // 编译 选项: g++ 2- 7- 4. cpp -std= c++ 11 -c

　　对于非常量的静态成员变量， C++ 11 则与 C++ 98 保持了一致。程序员还是需要到头文件以外去定义它，这会保证编译时，类静态成员的定义最后只存在于一个目标文件中。

9、sizeof

　　不过在 C++ 98 标准中，对 非静态成员变量 使用 sizeof 是不能够通过编译的。

#include < iostream> 
using namespace std;
struct People { 
  public: 
    int hand; 
    static People * all; 
}; 
int main() { 
    People p; 
    cout << sizeof( p. hand) << endl; // C++ 98 中 通过, C++ 11 中 通过 
    cout << sizeof( People:: all) << endl; // C++ 98 中 通过, C++ 11 中 通过 
    cout << sizeof( People:: hand) << endl; // C++ 98 中 错误, C++ 11 中 通过 
} // 编译 选项: g++ 2- 8- 1. cpp

　　而在 C++ 98 中，只有静态成员，或者 对象的实例 才能对其成员进行 sizeof 操作。因此如果读者只有一个支持 C++ 98 标准的编译器，在没有定义类实例的时候，要获得类成员的大小，我们通常会采用以下的代码：

sizeof((( People*) 0)-> hand);

10、而在 C++ 11 中，我们无需这样的技巧，因为 sizeof 可以作用的表达式包括了类成员表达式。

而在 C++ 11 中， 我们 无需 这样 的 技巧， 因为 sizeof 可以 作用 的 表达式 包括了 类 成员 表达式。

11、friend

　　C++98 中无法对 typedef 进行 friend. C++11中可以，并且C++11中省略了 class.

class Poly; 
typedef Poly P; 
class LiLei { 
    friend class Poly; // C++ 98 通过, C++ 11 通过 
}; 
class Jim { 
    friend Poly; // C++ 98 失败, C++ 11 通过 
}; 
class HanMeiMei { 
    friend P; // C++ 98 失败, C++ 11 通过 
}; // 编译 选项: g++ -std= c++ 11 2- 9- 1. cpp

　　C++11 中可以为类模板声明友元，这在C++98中是无法做到的。

class P; 
template < typename T> 
class People { friend T; }; 
People< P> PP; // 类型 P 在这里 是 People 类型 的 友 元 
People< int> Pi; // 对于 int 类型 模板 参数， 友 元 声明 被 忽略 
// 编译 选项: g++ -std= c++ 11 2- 9- 2. cpp

12、final / override

　　C++98 中没有方法阻止 vritual 函数被重载。

　　C++11 中添加了 final 关键字来实现此功能。

　　C++11 中，继承类重载时，最好加上 override 关键字，有了override 关键字，编译器可以帮助检测重载是否成功。

struct Base { 
    virtual void Turing() = 0; 
    virtual void Dijkstra() = 0; 
    virtual void VNeumann( int g) = 0; 
    virtual void DKnuth() const; 
    void Print(); 
}; 

struct DerivedMid: public Base { 
    // void VNeumann( double g); // 接口 被 隔离 了， 曾 想 多 一个 版本 的 VNeumann 函数 
}; 

struct DerivedTop : public DerivedMid { 
    void Turing() override; 
    void Dikjstra() override; // 无法 通过 编译， 拼写 错误， 并非 重载 
    void VNeumann( double g) override; // 无法 通过 编译， 参数 不一致， 并非 重载 
    void DKnuth() override; // 无法 通过 编译， 常量 性 不一致， 并非 重载 
    void Print() override; // 无法 通过 编译， 非 虚 函数 重载 
; // 编译 选项: g++ -c -std= c++ 11 2- 10- 3. cpp

13、函数模板的默认参数

　　C++98中，只有类模板参数可以有默认值，而函数模板不行。C++11中，这一限制已经解除了。

void DefParm( int m = 3) {} // c++ 98 编译 通过， c++ 11 编译 通过 

template < typename T = int> 
class DefClass {}; // 类模板参数，c++ 98 编译 通过， c++ 11 编译 通过 template 

< typename T = int> 
void DefTempParm() {}; // 函数模板参数，c++ 98 编译 失败， c++ 11 编译 通过

　　类模板的参数必须从右到左，而函数模板则无此规定。

template< typename T1, typename T2 = int> 
class DefClass1; 

template< typename T1 = int, typename T2> 
class DefClass2; // 无法 通过 编译 

template< typename T, int i = 0> 
class DefClass3; 

template< int i = 0, typename T> 
class DefClass4; // 无法 通过 编译 

template< typename T1 = int, typename T2> 
void DefFunc1( T1 a, T2 b); 

template< int i = 0, typename T> 
void DefFunc2( T a);

14、模板的显式实例化、外部模板声明。

　　C++98中已经有了模板显式实例化的功能。

// 对于以下模板
template < typename T> void fun( T) {}

// 像下面这样显式实例化
template void fun< int>( int);

　　C++11中加入了外部模板声明的功能。外部模板的声明跟显式的实例化差不多，只是多了一个关键字 extern。

extern template void fun< int>( int);

　　如果外部模板声明出现于某个编译单元中，那么与之对应的显示实例化必须出现于另一个编译单元中或者同一个编译单元的后续代码中；外部模板声明 不能用于静态函数（即文件域函数），但可以用于类静态成员函数（这一点是显而易见的，因为静态函数没有外部链接属性，不可能在本编译单元之外出现）。

　　外部模板定义更应该算作一种针对编译器的 编译时间及空间 的优化手段。很多时候，由于程序员低估了模板实例化展开的开销，因此大量的模板使用会在代码中产生大量的冗余。这种冗余，有的时候已经使得 编译器和链接器 力不从心。

15、局部、匿名类型作模板实参

　　局部的类型 和 匿名的类型 在 C++ 98 中都不能做 模板类的实参。

template < typename T> 
class X {}; 

template < typename T> 
void TempFun( T t){}; 

struct A{} a; 
struct {int i;} b; // b是 匿名类型变量 
typedef struct {int i;} B; // B是 匿名类型 

void Fun() { 
    struct C {} c; // C是 局部类型 
    
    X< A> x1; // C++ 98 ok， C++ 11 通过 
    X< B> x2; // C++ 98 fail， C++ 11 通过 
    X< C> x3; // C++ 98 fail， C++ 11 通过 
    
    TempFun( a); // C++ 98 ok， C++ 11 通过 
    TempFun( b); // C++ 98 fail， C++ 11 通过 
    TempFun( c); // C++ 98 fail， C++ 11 通过 
}

　　除了匿名的结构体（anonymous struct）之外，匿名的联合体（anonymous union）以及枚举类型（union），在 C++ 98 标准下也都是无法做模板的实参的。

　　如今看来这都是不必要的限制。所以在 C++ 11 中标准允许了以上类型做模板参数的做法。虽然如此，但以下写法是不被接受的。

template < typename T> 
struct MyTemplate { }; 
int main() {
    MyTemplate< struct { int a; }> t; // 无法 编译 通过, 匿名类型的声明不能在模板实参位置 
    return 0; 
} // 编译 选项: g++ -std= c++ 11 2- 13- 2. cpp