深刻理解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

相關標籤/搜索

每日一句

每一个你不满意的现在，都有一个你没有努力的曾经。