C++新標(biāo)準(zhǔn)難點(diǎn)解析之什么是可變模板參數(shù)

本篇內(nèi)容介紹了“C++新標(biāo)準(zhǔn)難點(diǎn)解析之什么是可變模板參數(shù)”的有關(guān)知識(shí)，在實(shí)際案例的操作過程中，不少人都會(huì)遇到這樣的困境，接下來(lái)就讓小編帶領(lǐng)大家學(xué)習(xí)一下如何處理這些情況吧！希望大家仔細(xì)閱讀，能夠?qū)W有所成！

 前言

C++的新特性--可變模版參數(shù)(variadic  templates)是C++新增的最強(qiáng)大的特性之一，它對(duì)參數(shù)進(jìn)行了高度泛化，它能表示0到任意個(gè)數(shù)、任意類型的參數(shù)。相比C++98/03，類模版和函數(shù)模版中只能含固定數(shù)量的模版參數(shù)，可變模版參數(shù)無(wú)疑是一個(gè)巨大的改進(jìn)。然而由于可變模版參數(shù)比較抽象，使用起來(lái)需要一定的技巧，所以它也是C++中最難理解和掌握的特性之一。雖然掌握可變模版參數(shù)有一定難度，但是它卻是C++11中最有意思的一個(gè)特性。

變模版參數(shù)的展開

可變參數(shù)模板和普通模板的語(yǔ)義是一樣的，只是寫法上稍有區(qū)別，聲明可變參數(shù)模板時(shí)需要在typename或class后面帶上省略號(hào)“...”。比如我們常常這樣聲明一個(gè)可變模版參數(shù)：template

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

省略號(hào)的作用:

1.聲明一個(gè)參數(shù)包T... args，這個(gè)參數(shù)包中可以包含0到任意個(gè)模板參數(shù); 2.在模板定義的右邊，可以將參數(shù)包展開成一個(gè)一個(gè)獨(dú)立的參數(shù)。

省略號(hào)的參數(shù)稱為“參數(shù)包”，它里面包含了0到N(N>=0)個(gè)模版參數(shù)。我們無(wú)法直接獲取參數(shù)包args中的每個(gè)參數(shù)的，只能通過展開參數(shù)包的方式來(lái)獲取參數(shù)包中的每個(gè)參數(shù)，這是使用可變模版參數(shù)的一個(gè)主要特點(diǎn)，也是最大的難點(diǎn)，即如何展開可變模版參數(shù)。

可變模板參數(shù)分類：

1.可變模版參數(shù)函數(shù)

2.可變模版參數(shù)類

打印可變模版參數(shù)函數(shù)的參數(shù)個(gè)數(shù)

#include <iostream> #include <string> using namespace std; template <class ...Type> void print(Type ...data)  {     cout << sizeof...(data) << endl; } int main()  {     print();     print(1);     print(1, "ILoveyou");     print(1, 2, 3.4, "IMissyou");     return 0; }

上面的例子中，print()沒有傳入?yún)?shù)，所以參數(shù)包為空，輸出的size為0，后面兩次調(diào)用分別傳入兩個(gè)和三個(gè)參數(shù)，故輸出的size分別為2和3。由于可變模版參數(shù)的類型和個(gè)數(shù)是不固定的，所以我們可以傳任意類型和個(gè)數(shù)的參數(shù)給函數(shù)print。這個(gè)例子只是簡(jiǎn)單的將可變模版參數(shù)的個(gè)數(shù)打印出來(lái)，如果我們需要將參數(shù)包中的每個(gè)參數(shù)打印出來(lái)的話就需要通過一些方法了。

展開可變模版參數(shù)函數(shù)的方法一般有兩種：

1.通過遞歸函數(shù)來(lái)展開參數(shù)包。

2.逗號(hào)表達(dá)式來(lái)展開參數(shù)包。

遞歸方式展開參數(shù)包

通過遞歸函數(shù)展開參數(shù)包，需要提供一個(gè)參數(shù)包展開的函數(shù)和一個(gè)遞歸終止函數(shù)，遞歸終止函數(shù)正是用來(lái)終止遞歸的，如下面的例子：

#include <iostream> using namespace std; //遞歸終止函數(shù) void print() {     cout << "遞歸終止函數(shù)" << endl; } //展開函數(shù) template <class T,class ...Type> void print(T data,Type...exData) {     cout << data << endl;     print(exData...); } int main() {     print(1, 2, 3, 4);     return 0; }

上例會(huì)輸出每一個(gè)參數(shù)，直到為空時(shí)輸出"遞歸終止函數(shù)"。展開參數(shù)包的函數(shù)有兩個(gè)，一個(gè)是遞歸函數(shù)，另外一個(gè)是遞歸終止函數(shù)，參數(shù)包exData...在展開的過程中遞歸調(diào)用自己，每調(diào)用一次參數(shù)包中的參數(shù)就會(huì)少一個(gè)，直到所有的參數(shù)都展開為止，當(dāng)沒有參數(shù)時(shí)，則調(diào)用非模板函數(shù)print終止遞歸過程。當(dāng)然上述終止函數(shù)也可以寫成帶參數(shù)函數(shù)模板:

template <class T> void print(T data) {  cout<<data<endll    }

接下來(lái)用模板函數(shù)作為終止函數(shù)寫一個(gè)不限參求和函數(shù)，具體實(shí)現(xiàn)代碼如下：

#include <iostream> using namespace std; //遞歸終止函數(shù) template <typename Type> Type sum(Type t)  {     return t; } //展開函數(shù) template <class T,class ...Type> T sum(T a, Type ...b)  {     return a + sum<T>(b...); } int main() {     cout << sum(1, 2, 3, 4) << endl;     cout << sum(1, 2, 3) << endl;     return 0; }

sum在展開參數(shù)包的過程中將各個(gè)參數(shù)相加求和，參數(shù)的展開方式和前面的打印參數(shù)包的方式是一樣的。

逗號(hào)表達(dá)式展開參數(shù)包

遞歸函數(shù)展開參數(shù)包是一種標(biāo)準(zhǔn)做法，也比較好理解，但也有一個(gè)缺點(diǎn),就是必須要一個(gè)重載的遞歸終止函數(shù)，即必須要有一個(gè)同名的終止函數(shù)來(lái)終止遞歸，這樣可能會(huì)感覺稍有不便。有沒有一種更簡(jiǎn)單的方式呢?其實(shí)還有一種方法可以不通過遞歸方式來(lái)展開參數(shù)包，這種方式需要借助逗號(hào)表達(dá)式和初始化列表。比如前面打印函數(shù)可以改成這樣：

#include <iostream> using namespace std; //遞歸終止函數(shù) template <class T> void print(T data)  {     cout << data << "\t"; } template <class ...Type> void print(Type ...exData)  {     int array[] = { (print(exData),0)... }; }  int main() {     print(1, 2, 3);     cout << endl;     print("張三", 1, 3);     return 0; }

這個(gè)數(shù)組的目的純粹是為了在數(shù)組構(gòu)造的過程展開參數(shù)包。我們可以把上面的例子再進(jìn)一步改進(jìn)一下，將函數(shù)作為參數(shù)，就可以支持lambda表達(dá)式了，從而可以少寫一個(gè)遞歸終止函數(shù)了，具體代碼如下：

C++中新特性之：initializer_list詳解

C++11提供的新類型，定義在頭文件中。

template< class T > class initializer_list;

下面稍微介紹一下initializer_list

一個(gè)initializer_list當(dāng)出現(xiàn)在以下兩種情況的被自動(dòng)構(gòu)造：

1. 鴻蒙官方戰(zhàn)略合作共建——HarmonyOS技術(shù)社區(qū)

2. 當(dāng)初始化的時(shí)候使用的是大括號(hào)初始化，被自動(dòng)構(gòu)造。包括函數(shù)調(diào)用時(shí)和賦值

3. 當(dāng)涉及到for(initializer： list),list被自動(dòng)構(gòu)造成initializer_list對(duì)象

也就是說(shuō)initializer_list對(duì)象只能用大括號(hào){}初始化。拷貝一個(gè)initializer_list對(duì)象并不會(huì)拷貝里面的元素。其實(shí)只是引用而已。而且里面的元素全部都是const的。下面一個(gè)例子可以幫助我們更好地理解如何使用initializer_list:

#include <iostream> #include <vector> #include <initializer_list>  using namespace std;  template <class T> struct S  {     vector<T> v;     S(initializer_list<T> l) : v(l) {         cout << "constructed with a " << l.size() << "-elements lists" << endl;     }     void append(std::initializer_list<T> l) {         v.insert(v.end(), l.begin(), l.end());     }      pair<const T*, size_t> c_arr() const {         return { &v[0], v.size() };     } }; template <typename T> void templated_fn(T arg) {     for (auto a : arg)         cout << a << " ";     cout << endl; }  int main()  {     S<int> s = { 1, 2, 3, 4, 5 };                     s.append({ 6, 7 , 8 });             for (auto n : s.v)         cout << ' ' << n;     cout << endl;     for (auto x : { -1, -2, 03 })           cout << x << " ";     cout << endl;     auto al = { 10, 11, 12 };      templated_fn<initializer_list<int> >({ 7, 8, 9 });      templated_fn<vector<int>>({ 3, 5, 7 });             return 0; }

可變模版參數(shù)類

std::tuple就是一個(gè)可變模板類

template< class... Types > class tuple;

這個(gè)可變參數(shù)模板類可以攜帶任意類型任意個(gè)數(shù)的模板參數(shù)：

tuple<int> tp1 = std::make_tuple(1); tuple<int, double> tp2 = std::make_tuple(1, 2.5); tuple<int, double, string> tp3 = std::make_tuple(1, 2.5, “”);

可變參數(shù)模板的模板參數(shù)個(gè)數(shù)可以為0個(gè)，所以下面的定義也是也是合法的：

tuple<> tp;

可變參數(shù)模板類的參數(shù)包展開的方式和可變參數(shù)模板函數(shù)的展開方式不同，可變參數(shù)模板類的參數(shù)包展開需要通過模板特化和繼承方式去展開，展開方式比可變參數(shù)模板函數(shù)要復(fù)雜。

模版偏特化和遞歸方式來(lái)展開參數(shù)包

基本的可變參數(shù)模板類

//前向聲明 template<typename... Args> struct Sum;  //基本定義 template<typename First, typename... Rest> struct Sum<First, Rest...> {     enum { value = Sum<First>::value + Sum<Rest...>::value }; };  //遞歸終止 template<typename Last> struct Sum<Last> {     enum { value = sizeof (Last) }; }; int main() {     cout << Sum<int, double, short>::value << endl;     return 0; }

繼承方式展開參數(shù)包

//整型序列的定義 template<int...> struct IndexSeq{};  //繼承方式，開始展開參數(shù)包 template<int N, int... Indexes> struct MakeIndexes : MakeIndexes<N - 1, N - 1, Indexes...> {};  // 模板特化，終止展開參數(shù)包的條件 template<int... Indexes> struct MakeIndexes<0, Indexes...> {     typedef IndexSeq<Indexes...> type; };  int main() {     using T = MakeIndexes<3>::type;     cout <<typeid(T).name() << endl;     return 0; }

可變參數(shù)模版消除重復(fù)代碼

C++11之前如果要寫一個(gè)泛化的工廠函數(shù)，這個(gè)工廠函數(shù)能接受任意類型的入?yún)?，并且參?shù)個(gè)數(shù)要能滿足大部分的應(yīng)用需求的話，我們不得不定義很多重復(fù)的模版定義，比如下面的代碼：

#include <iostream> using namespace std; template<typename T, typename...  Args> T* Instance(Args... args) {     return new T(args...); } class A { public:     A(int a) :a(a) {}     A(int a, int b) :a(a) {}     A(int a, int b,string c) :a(a) {}     void print()      {         cout << a << endl;     }     int a; }; class B  { public:     B(int a, int b) :a(a), b(b) {}     void print()     {         cout << a << endl;         cout << b << endl;     }     int a;     int b; }; int main() {     A* pa = Instance<A>(1);     B* pb = Instance<B>(1, 2);     pa->print();     pb->print();     pa = Instance<A>(100, 2);     pa->print();     pa = Instance<A>(100, 2,"Loveyo");     pa->print();     return 0; }

 萬(wàn)能函數(shù)

template <class T, class R, typename... Args> class  MyDelegate { public:     MyDelegate(T* t, R  (T::*f)(Args...) ):m_t(t),m_f(f) {}     R operator()(Args... args)     {         return (m_t->*m_f)(args ...);     }     //R operator()(Args&&... args)      //{             //return (m_t->*m_f)(std::forward<Args>(args) ...);     //}  private:     T* m_t;     R  (T::*m_f)(Args...); };     template <class T, class R, typename... Args> MyDelegate<T, R, Args...> CreateDelegate(T* t, R (T::*f)(Args...)) {     return MyDelegate<T, R, Args...>(t, f); }  struct A {     void Fun(int i){cout<<i<<endl;}     void Fun1(int i, double j){cout<<i+j<<endl;} };  int main() {     A a;     auto d = CreateDelegate(&a, &A::Fun); //創(chuàng)建委托     d(1); //調(diào)用委托，將輸出1     auto d1 = CreateDelegate(&a, &A::Fun1); //創(chuàng)建委托     d1(1, 2.5); //調(diào)用委托，將輸出3.5 } 

“C++新標(biāo)準(zhǔn)難點(diǎn)解析之什么是可變模板參數(shù)”的內(nèi)容就介紹到這里了，感謝大家的閱讀。如果想了解更多行業(yè)相關(guān)的知識(shí)可以關(guān)注億速云網(wǎng)站，小編將為大家輸出更多高質(zhì)量的實(shí)用文章！