深刻理解C++11【4】

時間 2020-08-12

標籤深刻理解 c++11 欄目 C&C++ 简体版

原文原文鏈接

【深刻理解C++11【4】】ios

一、基於範圍的 for 循環程序員

　　C++98 中須要告訴編譯器循環體界面範圍。如for，或stl 中的for_each：算法

int main() { int arr[ 5] = { 1, 2, 3, 4, 5}; int * p; for (p = arr; p < arr + sizeof( arr)/ sizeof( arr[ 0]); ++ p){ *p *= 2; } for (p = arr; p < arr + sizeof( arr)/ sizeof( arr[ 0]); ++ p){ cout << *p << '\t'; } }

View Code

int action1( int & e){ e *= 2; } int action2( int & e){ cout << e << '\t'; } int main() { int arr[ 5] = { 1, 2, 3, 4, 5}; for_ each( arr, arr + sizeof( arr)/ sizeof( arr[ 0]), action1); for_ each( arr, arr + sizeof( arr)/ sizeof( arr[ 0]), action2); }

　　由程序員來講明循環的範圍是多餘的，也是容易犯錯誤的。而 C++ 11 也引入了基於範圍的 for 循環，就能夠很好地解決了這個問題。express

int main() { int arr[ 5] = { 1, 2, 3, 4, 5 }; for (int & e: arr) e *= 2; for (int & e: arr) cout << e << '\t'; }

　　上棕採用了引用的形式，也能夠不採用引用的形式。編程

for (int e: arr) cout << e << '\t';

　　結合以前的 auto，會更簡練。數組

for (auto e: arr) cout << e << '\t';

　　下述代碼會報錯，由於 做爲參數傳遞而來的數組 a 的範圍不能肯定，所以也就不能使用基於範圍循環 for 循環對其進行迭代的操做。app

int func( int a[]) { for (auto e: a) cout << e; } int main() { int arr[] = {1, 2, 3, 4, 5}; func( arr); }

二、枚舉：分門別類與數值的名字。less

　　覺的常量定義方式：ide

　　1）宏。宏的弱點在於其定義的只是預處理階段的名字，若是代碼中有 Male 或者 Female 的字符串，不管在什麼位置一概將被替換。這在有的時候會干擾到正常的代碼，函數

#define Male 0 
#define Female 1

　　2）枚舉。相比於宏，會獲得編譯器的檢查。且不會有干擾正常代碼的尷尬。

enum { Male, Female };

　　3）靜態常量。因爲是靜態常量，其名字做用域也被很好地侷限於文件內。

const static int Male = 0; const static int Female = 1;

三、有缺陷的枚舉類型

　　C/ C++ 的 enum 有個很「奇怪」的設定，就是具名（有名字）的 enum 類型的名字，以及 enum 的成員的名字都是全局可見的。下面代碼，Category 中的 General 和 Type 中的 General 都是全局的名字，所以 編譯會報錯。

enum Type { General, Light, Medium, Heavy }; enum Category { General, Pistol, MachineGun, Cannon };

　　匿名space的 enum仍是會污染全局空間。以下：

namespace T { enum Type { General, Light, Medium, Heavy }; } namespace { enum Category { General = 1, Pistol, MachineGun, Cannon }; } int main() { T:: Type t = T:: Light; if (t == General) // 忘記 使用 namespace 
        cout << "General Weapon" << endl; return 0; }

　　C++98 中並不會阻止不一樣enum 間的比較。

enum Type { General, Light, Medium, Heavy }; //enum Category { General, Pistol, MachineGun, Cannon }; // 沒法 編譯 經過， 重複 定義 了 General 
enum Category { Pistol, MachineGun, Cannon }; int main() { Type type1; if (type1 >= Pistol) cout << "It is not a pistol" << endl; }

　　C++98 中能夠經過封閉來解決上述污染和類型比較的問題。

class Type { public: enum type { general, light, medium, heavy }; type val; public: Type( type t): val( t){} bool operator >= (const Type & t) { return val >= t. val; } static const Type General, Light, Medium, Heavy; }; const Type Type:: General( Type:: general); const Type Type:: Light( Type:: light); const Type Type:: Medium( Type:: medium); const Type Type:: Heavy( Type:: heavy); class Category { public: enum category { pistol, machineGun, cannon }; category val; public: Category( category c): val( c) {} bool operator >= (const Category & c) { return val >= c. val; } static const Category Pistol, MachineGun, Cannon; }; const Category Category:: Pistol( Category:: pistol); const Category Category:: MachineGun( Category:: machineGun); const Category Category:: Cannon( Category:: cannon); struct Killer { Killer( Type t, Category c) : type( t), category( c){} Type type; Category category; }; int main() { // 使用 類型 包裝 後的 enum 
 Killer notCool( Type:: General, Category:: MachineGun); // ... // ...其餘 不少 代碼... // ... 
    if (notCool. type >= Type:: General) // 能夠 經過 編譯 
        cout << "It is not general" << endl; if (notCool. type >= Category:: Pistol) // 該 句 沒法 編譯 經過 
        cout << "It is not a pistol" << endl; // ... 
        cout << is_ pod< Type>:: value << endl; // 0 
        cout << is_ pod< Category>:: value << endl; // 0 
    return 0; }

View Code

　　編譯器會根據數據類型的不一樣對 enum 應用不一樣的數據長度。在咱們對 g++ 的測試中，普通的枚舉使用了 4 字節的內存，而當須要的時候，會拓展爲 8 字節。

enum C { C1 = 1, C2 = 2}; enum D { D1 = 1, D2 = 2, Dbig = 0xFFFFFFF0U }; enum E { E1 = 1, E2 = 2, Ebig = 0xFFFFFFFFFLL}; int main() { cout << sizeof( C1) << endl; // 4 
    cout << Dbig << endl; // 編譯器 輸出 不一樣, g++： 4294967280 
    cout << sizeof( D1) << endl; // 4 
    cout << sizeof( Dbig) << endl; // 4 
    cout << Ebig << endl; // 68719476735 
    cout << sizeof( E1) << endl; // 8 
    return 0; }

　　不一樣的編譯器，上例中 Dbig 的輸出結果將會不一樣：使用 Visual C++ 編譯程序的輸出結果爲– 16，而使用 g++ 來編譯輸出爲 4294967280。這是因爲 Visual C++ 老是使用無符號類型做爲枚舉的底層實現，而 g++ 會根據枚舉的類型進行變更形成的。

四、強類型枚舉（strong-typed enum）以及 C++ 11 對原有枚舉類型的擴展

　　聲明強類型枚舉很是簡單，只需要在 enum 後加上關鍵字 class。

enum class Type { General, Light, Medium, Heavy };

　　強類型枚舉有如下幾個優點：

　　1）強做用域，強類型枚舉成員的名稱不會被輸出到其你做用域空間。

　　2）轉換限制，強類型枚舉成員的值不能夠與整形隱式地相互轉換。

　　3）能夠指定底層類型。強類型枚舉默認的底層類型爲 int, 但也能夠顯式地指定底層類型。

enum class Type: char { General, Light, Medium, Heavy };

　　下面是一個強類型枚舉的例子：

enum class Type { General, Light, Medium, Heavy }; enum class Category { General = 1, Pistol, MachineGun, Cannon }; int main() { Type t = Type:: Light; t = General; // 編譯 失敗， 必須 使用 強 類型 名稱 
    
    if (t == Category:: General) // 編譯 失敗， 必須 使用 Type 中的 General 
        cout << "General Weapon" << endl; if (t > Type:: General) // 經過 編譯 
        cout << "Not General Weapon" << endl; if (t > 0) // 編譯 失敗， 沒法 轉換 爲 int 類型 
        cout << "Not General Weapon" << endl; if ((int) t > 0) // 經過 編譯 
        cout << "Not General Weapon" << endl; cout << is_ pod< Type>:: value << endl; // 1 
    cout << is_ pod< Category>:: value << endl; // 1 
    
    return 0; }

　　設置較小的基本類型能夠節省空間：

enum class C : char { C1 = 1, C2 = 2}; enum class D : unsigned int { D1 = 1, D2 = 2, Dbig = 0xFFFFFFF0U }; int main() { cout << sizeof( C:: C1) << endl; // 1 
    cout << (unsigned int) D:: Dbig << endl; // 編譯器 輸出 一致, 4294967280 
    cout << sizeof( D:: D1) << endl; // 4 
    cout << sizeof( D:: Dbig) << endl; // 4 
    return 0; }

　　C++11加強了原有枚舉類型：

　　1）能夠跟強類型枚舉類同樣，顯式地由程序員來指定。

enum Type: char { General, Light, Medium, Heavy };

　　2）擴展做用域。除了增長到父做用域外，還增長到自身做用域，二者等價。

enum Type { General, Light, Medium, Heavy }; Type t1 = General; Type t2 = Type:: General;

　　此外，咱們在聲明強類型枚舉的時候，也能夠使用關鍵字 enum struct。事實上 enum struct 和 enum class 在語法上沒有任何區別（ enum class 的成員沒有公有私有之分，

　　有一點比較有趣的是匿名的 enum class。因爲 enum class 是強類型做用域的，故匿名的 enum class 極可能什麼都作不了。

enum class { General, Light, Medium, Heavy } weapon; int main() { weapon = General; // 沒法 編譯 經過 
    bool b = (weapon == weapon:: General); // 沒法 編譯 經過 
    return 0; }

五、顯式內存管理。

　　常見內存管理問題：

　　1）野指針、重複釋放。指向指向內存已被釋放，但指針卻還在被使用。

　　2）內存泄露。指針已經丟失，但其指向內存並未被釋放。

　　C++98中的智能指針是 auto_ptr，不過 auto_ ptr 有一些缺點（拷貝時返回一個左值，不能調用 delete[] 等），因此在 C++ 11 標準中被廢棄了。 C++ 11 標準中改用 unique_ ptr、 shared_ ptr 及 weak_ ptr 等智能指針來自動回收堆分配的對象。

　　下面是 unique_ptr、shared_ptr 的例子：

#include < memory> #include < iostream> 
using namespace std; int main() { unique_ ptr< int> up1( new int( 11)); // 沒法 複製 的 unique_ ptr 
    unique_ ptr< int> up2 = up1; // 不能 經過 編譯 
    cout << *up1 << endl; // 11 
    unique_ ptr< int> up3 = move( up1); // 如今 p3 是 數據 惟一 的 unique_ ptr 智能 指針 
    cout << *up3 << endl; // 11 
    cout << *up1 << endl; // 運行時 錯誤 
    up3. reset(); // 顯 式 釋放 內存 
    up1. reset(); // 不會 致使 運行時 錯誤 
    cout << *up3 << endl; // 運行時 錯誤
 shared_ ptr< int> sp1( new int( 22)); shared_ ptr< int> sp2 = sp1; cout << *sp1 << endl; // 22 
    cout << *sp2 << endl; // 22 
 sp1. reset(); cout << *sp2 << endl; // 22 
}

　　unique_ ptr 則是一個刪除了拷貝構造函數、保留了移動構造函數的指針封裝類型。

　　shared_ptr 在實現上採用了引用計數，因此一旦一個 shared_ ptr 指針放棄了「全部權」（失效），其餘的 shared_ ptr 對對象內存的引用並不會受到影響。

　　weak_ptr 可以指向 shared_ ptr 指針指向的對象內存，卻並不擁有該內存。而使用 weak_ ptr 成員 lock，則可返回其指向內存的一個 shared_ ptr 對象，且在所指對象內存已經無效時，返回指針空值（ nullptr，請參見 7. 1 節）。這在驗證 share_ ptr 智能指針的有效性上會很有做用。以下：

#include < memory> #include < iostream> 
using namespace std; void Check( weak_ ptr< int> & wp) { shared_ ptr< int> sp = wp. lock(); // 轉換 爲 shared_ ptr< int> 
    
    if (sp != nullptr) cout << "still " << *sp << endl; else cout << "pointer is invalid." << endl; } int main() { shared_ ptr< int> sp1( new int( 22)); shared_ ptr< int> sp2 = sp1; weak_ ptr< int> wp = sp1; // 指向 shared_ ptr< int> 所指 對象 
    cout << *sp1 << endl; // 22 
    cout << *sp2 << endl; // 22 
    Check( wp); // still 22 
 sp1. reset(); cout << *sp2 << endl; // 22 
    Check( wp); // still 22 
 sp2. reset(); Check( wp); // pointer is invalid
}

六、垃圾回收的分類。

　　垃圾回收的方式能夠分爲兩大類：

　　1）基於引用計數。這種方法比較難處理「環形引用」問題，此外因爲計數帶來的額外開銷也並不小。

　　2）基於跟蹤處理。跟蹤處理的垃圾回收機制被更爲普遍地應用。主要有如下幾種方法：

　　　　a）標記 - 清除（Mark-Sweep）

　　　　　　這種方法的特色是活的對象不會被移動，可是其存在會出現大量的內存碎片的問題。

　　　　b）標記 - 整理（Mark-Compact）

　　　　　　這個算法標記的方法和標記- 清除方法同樣，可是標記完以後，再也不遍歷全部對象清掃垃圾了，而是將活的對象向「左」靠齊，這就解決了內存碎片的問題。

　　　　c）標記 - 拷貝（Mark-Copy）

　　　　　　標記– 整理算法的另外一種實現。這種算法將堆空間分爲兩個部分： From 和 To。

　　C++ 11 標準也開始對垃圾回收作了必定的支持，雖然支持的程度還很是有限。

七、C++ 與垃圾回收。

　　由於C++中能夠自由移動指針，因此若是加入垃圾回收，有可能將有用的內存回收，從而致使重大內存問題。

int main() { int* p = new int; p += 10; // 移動 指針， 可能 致使 垃圾 回收 器 
    p -= 10; // 回收 原來 指向 的 內存 
    *p = 10; // 再次 使用 本來 相同 的 指針 則 可能 無效 
}

　　下例也是同樣，隱藏原始指針，可能致使內存被回收問題。

int main() { int *p = new int; int *q = (int*)( reinterpret_ cast< long long>( p) ^ 2012); // q 隱藏 了 p // 作 一些 其餘 工做， 垃圾 回收 器 可能 已經 回收 了 p 指向 對象 
    q = (int*)( reinterpret_ cast< long long>( q) ^ 2012); // 這裏 的 q == p 
    *q = 10; }

八、C++11 與最小垃圾回收支持。

　　截至2013年，幾乎沒有編譯器實現了最小垃圾回收支持，甚至連 get_ pointer_ safety 這個函數接口都還沒實現。

　　declare_ reachable() 顯式地通知垃圾回收器某一個對象應被認爲可達的，即便它的全部指針都對回收器不可見。 undeclare_ reachable() 則能夠取消這種可達聲明。

#include < memory> 
using namespace std; int main() { int *p = new int; declare_ reachable( p); // 在 p 被 隱藏 以前 聲明 爲 可達 的 
    int *q = (int*)(( long long) p ^ 2012); // 解除 可達 聲明 
    q = undeclare_ reachable< int>(( int*)(( long long) q ^ 2012)); *q = 10; }

　　有的時候程序員會選擇在一大片連續的堆內存上進行指針式操做，爲了讓垃圾回收器不關心該區域，也能夠使用 declare_ no_ pointers 及 undeclare_ no_ pointers 函數來告訴垃圾回收器該內存區域不存在有效的指針。

void declare_ no_ pointers( char *p, size_ t n) noexcept; 
void undeclare_ no_ pointers( char *p, size_ t n) noexcept;

九、垃圾回收的兼容性。

　　C++ 11 標準中對指針的垃圾回收支持僅限於系統提供的 new 操做符分配的內存，而 malloc 分配的內存則會被認爲老是可達的，即不管什麼時候垃圾回收器都不予回收。所以使用 malloc 等的較老代碼的堆內存仍是必須由程序員本身控制。

十、運行時常量性與編譯時常量性。

　　const用於保證運行期常量性，但有時候，咱們須要的倒是編譯時的常量性，這是const關鍵字沒法保證的。

const int GetConst() { return 1; } void Constless( int cond) { int arr[ GetConst()] = {0}; // 沒法 經過 編譯 
    enum { e1 = GetConst(), e2 }; // 沒法 經過 編譯 
    switch (cond) { case GetConst(): // 沒法 經過 編譯 
            break; default: break; } }

　　上述代碼，咱們發現，不管將 GetConst 的結果用於須要初始化數組 Arr 的聲明中，仍是用於匿名枚舉中，或用於 switch- case 的 case 表達式中，編譯器都會報告錯誤。

　　發生這樣錯誤的緣由如咱們上面提到的同樣，這些語句都需要的是編譯時期的常量值。而 const 修飾的函數返回值，只保證了在運行時期內其值是不能夠被更改的。這是兩個徹底不一樣的概念。

enum BitSet { V0 = 1 << 0, V1 = 1 << 1, V2 = 1 << 2, VMAX = 1 << 3 }; // 重定 義 操做 符"|", 以 保證 返回 的 BitSet 值 不超過 枚舉 的 最大值 
const BitSet operator|( BitSet x, BitSet y) { return static_ cast< BitSet>((( int) x | y) & (VMAX - 1)); } template < int i = V0 | V1> // 沒法 經過 編譯 
void LikeConst(){}

　　上述代碼，咱們將 V0| V1 做爲非類型模板函數的默認模板參數，則會致使編譯錯誤。這一樣是由需要的是編譯時常量所致使的。

　　宏能夠解決上述問題，但這種簡單粗暴的作法即便有效，也會把 C++ 拉回「石器時代」。 C++ 11 中對編譯時期常量的回答是 constexpr，即 常量表達式（ constant expression）。

constexpr int GetConst() { return 1; }

　　在函數表達式前加上 constexpr 關鍵字便可。有了常量表達式這樣的聲明，編譯器就可以在編譯時期對 GetConst 表達式進行值計算（ evaluation），從而將其視爲一個編譯時期的常量。

　　這樣一來上述代碼數組 Arr、匿名枚舉的初始化以及 switch- case 的 case 表達式經過編譯都再也不是問題。

十一、常量表達式函數。

　　並不是全部的函數都有資格成爲常量表達式函數。事實上，常量表達式函數的要求很是嚴格，總結起來，大概有如下幾點：

　　1）函數體只有單一的return返回語句。例如，下面的的寫會編譯錯誤：

constexpr int data() { const int i = 1; return i; }

　　不過一些不會產生實際代碼的語句在常量表達式函數中使用下，倒不會致使編譯器的「抱怨」。

constexpr int f( int x) { static_ assert( 0 == 0, "assert fail."); return x; }

　　上面例子可以經過編譯。而其餘的，好比 using 指令、 typedef 等也一般不會形成問題。

　　2）函數必須返回值（不能是void函數）。例如，下面的寫法，就不能經過：

constexpr void f(){}

　　3）在使用前必須已有定義。

constexpr int f(); int a = f(); const int b = f(); constexpr int c = f(); // 沒法 經過 編譯 
constexpr int f() { return 1; } constexpr int d = f();

　　constexpr 不算重載，會致使編譯錯誤。

constexpr int f(); int f();

　　4）return 返回語句表達式中不能使用非常量表達式的函數、全局數據，且必須是一個常量表達式。例如如下constexpr不能經過編譯。

const int e(){ return 1;} constexpr int g(){ return e(); } // 編譯錯誤

int g = 3; constexpr int h() { return g; } // 編譯錯誤

　　另外，constexpr中賦值語句也是不容許的。如下會編譯錯誤。

constexpr int k( int x) { return x = 1; }

十二、常量表達式的值。

　　C++ 11 標準中， constexpr 關鍵字是不能用於修飾自定義類型的定義的。如下代碼，沒法經過編譯。

constexpr struct MyType {int i; } constexpr MyType mt = {0};

　　正確地作法是，定義自定義 常量構造函數（ constent- expression constructor）。

struct MyType { constexpr MyType( int x): i( x){} int i; }; constexpr MyType mt = {0};

　　常量表達式的構造函數也有使用上的約束，主要的有如下兩點：

　　1）函數體必須爲空。

　　2）初始化列表只能由常量表達式來賦值。例如，如下常量構造函數是錯誤的。

int f(); struct MyType {int i; constexpr MyType():i(f()){}};

　　常量構造函數、成員函數的區別：

struct Date { constexpr Date(int y, int m, int d): year(y), month(m),day(d){} constexpr int GetYear() { return year; } constexpr int GetMonth() { return month; } constexpr int GetDay() { return day; } private: int year; int month; int day; } constexpr Date PRCfound {1949,10,1}; constexpr int foundmont = PRCfound.GetMonth(); int main() { count << foundmonth << endl; // 10
}

View Code

　　C++11中，不容許常量表達式做用於 virtual 成員函數。

1三、常量表達式的其餘應用

　　常量表達式能夠用於模板函數。不過因爲模板中類型的不肯定性，因此模板函數是否會被實例化爲一個可以知足編譯時常量性的版本一般也是未知的。　　

　　C++11規定，當聲明爲常量表達式的模板函數後，而某個該模板函數的實例化結果不知足常量表達式的需求的話，constexpr會被自動忽略。該實例化後的函數將成爲一個普通函數。

struct NotLiteral{ NotLiteral(){i=5;} int i; }; NotLiteral nl; template<typename T> constexpr T ConstExp(T t){ return t; } void g(){ NotLiteral nl; NotLiteral nl1 = ConstExp(nl); constexpr NotLiteral nl2 = ConstExp(nl); // 沒法經過編譯
    constexpr int a = ConstExp(1); }

　上述代碼，NotLiteral不是一個定義了常量表達式構造函數的類型，ConstExp一旦以 NotLiteral爲參數的話，那麼其 constexpr關鍵字將被忽略，因此 ConstExp<NotLiteral>函數不是一個常量表達式函數。

　　C++11 標準對常量表達式支持至少 512層遞歸。

constexpr int Fibonacci(int n){ return (n==1)?1:((n--2)?1:Fibonacci(n-1)+Fibonacci(n-2)); } int main(){ int fib[] = { Fibonacci(11), Fibonacci(12), Fibonacci(13), Fibonacci(14), Fibonacci(15), Fibonacci(16) }; for (int i : fib) cout<<i<<endl; }

　　在C++98中，上述常量表達式函數遞歸能夠經過模板元編程來完成。

template<long num>
struct Fibonacci{ static const long val = Fibonacci<num-1>::val + Fibonacci<num-2>::val; } template<> struct Fibonacci<2> { static const long val =1; } template<> struct Fibonacci<1> { static const long val =1; } template<> struct Fibonacci<0> { static const long val =0; }

1四、變長函數和變長的模板參數

　　C++98 中使用 va_start、va_arg、 va_end 來實現變長函數參數功能。

double SumOfFloat(int count, ...){ va_list ap; ouble sum = 0; va_start(ap, count); for(int i = 0; i < count; i++) sum++ va_arg(ap, double); va_end(ap); return sum(); } int main(){ return printf("%f\n", SumOfFloat(3,1.2f,3.4,5.6)); }

　　C++98要求函數模板始終具備數目肯定的模板參數。

1五、變長模板：模板參數包和函數參數包

　　標識符前加三個點，表示該參數是變長的。Elements被稱爲模板參數包（template parameter pack）。

template <typename... Elements>
class tuple;

　　模板參數包也能夠是非類型的，例如：

template<int... A> class NonTypeVariadicTemplate{}; NonTypeVariadicTemplate<1,0,2> ntvt;

　　解包（unpack）在尾部添加三個點。下面這個叫包擴展（pack expansion）表達式。

template<typename... A> class Template : private B<A...>{};

　　上面只是展開了 A...，但沒有使用展開後的內容。Tunple 的實現中，展現了一種使用包括展的方法，數學概括法（遞歸）。這與模板元編程，constexpr很是類似。

// 變長模板的聲明
template <typename... Elements> class tuple; // 遞歸的偏特化的定義
template <typename Head, typename... Tail>
class tuple<Head, Tail...>:private tuple<Tail...>{ Head head; }; // 邊界條件
template<> class tuple<>{};

　　下面是一個使用非類型模板的例子。

// 聲明
template <long... nums> struct Multiply; // 偏特化
template <long first, long... last>
struct Multiply<first, last...>{ static const long val = first*Multiply<last...>::val; }; // 邊界條件
template<>
struct Multiply<>{ static const long val = 1; };

　　C++11中，還能夠聲明變長模板函數。變長模板函數的參數能夠聲明成爲函數參數包（function parameter pack）。

template<typename... T> void f(T... args);

　　C++11中，標準要求函數參數包必須惟一，且是函數最後一個參數（模板參數包沒有這樣的要求）。

　　有了模板參數包、函數參數包，就能夠實現C中變長函數的功能了。

void Printf(const char* s) { while(*s){ if(*s=='%'&&*++s!='%') throw runtime_error("invalid format string"); cout<<*s++; } } template<typename T, typename... Args>
void Printf(const char*s, T value, Args... args) { while(*s){ if(*s=='%'&&*++s!='%'){ cout<<value; return Printf(++s, args...); } cout<<*s++; } throw runtime_error("extra arguments provided to Printf"); } int main(){ Printf("hello %s\n", string("world")); // hello world
}

1六、變長模板：進階

　　注意到前面的程序，包擴展形式以下：

template<typename... A> class T: private B<A...> {}; // 上述模板 T<X,Y> 將會解包爲：
class T<X,Y>:private B<X,Y> {}; template<typename... A> class T : private B<A>...{}; // 上述模板 T<X,Y> 將會解包爲:
class T<X,Y>:private B<X>, private B<Y>{};

　　也即，解包發生成繼承基類模板時。B<A...> pack expasion 發生在<>內。而 B<A>... pack expasion 發生在 <>外。

　　類型的解包也能夠發生在使用模板函數時。以下：

template<truename... T> void DummyWrapper(T... t){} template<typename T> T pr(T t){ cout << t; return t; } template<typename... A>
void VTPrint(A... a){ DummyWrapper(pr(a)...); // 包擴展爲 pr(1), pr(", "), ..., pr(", abc\n")
} int main() { VTPrint(1,", ", 1.2, ", abc\n"); }

　　C++11中引入了新操做符「sizeof...」（sizeof後面加上了3個小點），其做用是計算參數包中的參數個數。下面是一個示例：

template<class...A> void Print(A... arg){ assert(false); // 非6參數偏特化都會默認assert(false)
} // 特化6參數的版本
void Print(int a1, int a2, int a3, int a4, int a5, int a6){ cout<<a1<<", "<<a2<<", "<<a3<<", "
        <<a4<<", "<<a5<<", "<<a6<<endl; } template<class...A> int Vaargs(A... args){ int size = sizeof...(A); // 計算變長包的長度
    switch(size){ case 0: Print(99, 99, 99, 99, 99, 99); break; case 1: Print(99,99,args...,99,99,99); break; case 2: Print(99,99,args...,99,99); break; case 3: Print(args...,99,99,99); break; case 4: Print(99,args...,99); break; case 5: Print(99,args...); break; case 6: Print(args...); break; case default: Print(0,0,0,0,0,0); } } int main(void) { Vaargs(); // 99,99,99,99,99,99
    Vaargs(1);    // 99,99,1,99,99,99
    Vaargs(1,2);    // 99,99,1,2,99,99
    Vaargs(1,2,3);    // 1,2,3,99,99,99
    Vaargs(1,2,3,4);    // 99,1,2,3,4,99
    Vaargs(1,2,3,4,5);    // 99,1,2,3,4,5
    Vaargs(1,2,3,4,5,6);    // 99,1,2,3,4,5,6
    Vaargs(1,2,3,4,5,6,7);    // 0,0,0,0,0,0
    return 0; }

　　使用模板作變長模板參數包：

template<typename I, template<typename> class... B> struct Container{}; template<typename I, template<typename> class A, template<typename> class... B>
struct Container<I, A,B...>{ A<I> a; Container<I,B...> b; } template<truename I> struct Container<I>{};

　　下述代碼會編譯錯誤，模板參數包不是變長模板類的最後一個參數。

template<class...A, class...B> struct Container{}; template<class...A, class B> struct Container{};

相關標籤/搜索

每日一句

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