深刻理解C++11

时间 2019-12-04

标签深刻理解 c++11 栏目 C&C++ 繁體版

原文原文链接

【深刻理解C++11】ios

一、不少现实的编译器都支持 C99 标准 中的__ func__ 预约义标识符功能，其基本功能就是返回所在函数的名字。c++

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

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

　　__func__ 能够用于构造函数中。ide

#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__) {};// 没法 经过 编译

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

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

　　一个应用的例子。this

#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

三、long long 是C99标准。C++11中才将其定为正式标准。事实上，在C++11之前，不少编译器也支持了long long。spa

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

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

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。

四、__cplusplus

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

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

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

五、assert，运行时检查

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

　　在 C++ 中，程序员也能够定义宏 NDEBUG 来禁用 assert 宏。这对发布程序来讲仍是必要的。

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

　　能够看到，一旦定义了 NDBUG 宏， assert 宏将被展开为一条无心义的 C 语句（一般会被编译器优化掉）。

六、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

七、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)，从而阻止了异常的扩散。

八、在 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 保持了一致。程序员仍是须要到头文件之外去定义它，这会保证编译时，类静态成员的定义最后只存在于一个目标文件中。

九、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);

十、而在 C++ 11 中，咱们无需这样的技巧，由于 sizeof 能够做用的表达式包括了类成员表达式。

而在 C++ 11 中， 咱们 无需 这样 的 技巧， 由于 sizeof 能够 做用 的 表达式 包括了 类 成员 表达式。

十一、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

十二、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

1三、函数模板的默认参数

　　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);

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

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

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

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

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

extern template void fun< int>( int);

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

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

1五、局部、匿名类型做模板实参

　　局部的类型 和 匿名的类型 在 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