cpp 11&14 可变参数模板与空指针,auto

Posted on Edited on In , , Changyan: Symbols count in article: 3k Reading time ≈ 3 mins.

  • Variadic Templates(可变参数模板)

    1
    2
    3
    4
    5
    6
    7
    8
    9
    10
    11
    12
    // 可变参数模板
    // 无参数函数，用于结束调用 
    void printX(){

    }
    // 包含一个参数固定参数的可变模板函数
    template <typename T,typename... types>
    void printX(const T& firstArg,const Types&... args){
        cout<< firstArg<<endl;
        printX(args...);
    }

  • 空指针

    1
    2
    3
    4
    5
    void f(int a){}//function1
    void f(void* a){}//funtion2
    f(NULL);//call function1 
    f(0);//call function1 
    f(nullptr);//call function2

  • 模板函数书写变化

    1
    2
    vector<vector<int> >//
    vector<vector<int>>//Ok since c++11

    cpp 11&14 可变参数模板与空指针,auto

Variadic Templates(可变参数模板)

帮助我们实现递归

code

基本使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// 可变参数模板
// 无参数函数，用于结束调用 
void printX(){

}
// 包含一个参数固定参数的可变模板函数
template <typename T,typename... types>


// type2 和 type 3 可以并存 2为特

// type2 接收1个和各式各样的入参
void printX(const T& firstArg,const Types&... args){
    cout<< firstArg<<endl;
    cout<< sizeof...(args...)<<endl;// 可以使用sizeof...(args) 获取args的个数
    printX(args...);
}
// type3 接收各式各样的入参
void printX(const Types&... args){
    cout<< firstArg<<endl;
    cout<< sizeof...(args...)<<endl;// 可以使用sizeof...(args) 获取args的个数
    printX(args...);

}

cpp库函数举例

calculate Hash
1
2
3
4
5
6
// another file
#include <functional>
template <typename T>
inline void hash_combine(size_t& seed,const T& val){
    seed^=std::hash<T>()(val)+0x9e3779b9+(seed<<6)+(seed>>2);
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25

// call sequence 1->2->recurse->3

// function 1
template<typename T,typename.. Type>
inline hash_val(size_t& seed, const T& val,const Types&... args){
    hash_combine(seed,val);
    hash_val(seed,args...);
}
// function 2
// auxiliary generic function
template <typeame... Types>
inline size_t hash_val(const Types&... args){
    size_t seed=0;
    hash_val(seed,args);
    return seed;
}

// function 3
// auxiliary generic function
template <typeame T>
inline size_t hash_val(size_t& seed,const T& val){
    hash_combine(seed,val);
}

tuple realise
1
2
template <typename... Values>class tuple;
template <>class tuple<>{};
1
2
3
4
5
6
7
8
9
10
11
12
13
template<typename Head,typename... Tail>
class tuple<Head,Tail...>:private typle<Tail...>{
    typedef typle<Tail...> inherited;
 
pubic:
    tuple(){}
    tuple(Head v,Tail... vtail):m_head(v),inherited(vtail...){}
typename Head::type head(){return m_head;}
inherited& tail(){return *this;}

protected:
Head m_head;
};
tuple sample
1
2
3
4
tuple<int,float,string> t(41,6.3,"nico");
t.head();//->4.1
t.tail().head()//->6.3

nullptr(空指针)

用于区分空指针与NULL

code

1
2
3
4
5
void f(int a){}//function1
void f(void* a){}//funtion2
f(NULL);//call function1 
f(0);//call function1 
f(nullptr);//call function2

file_name

1
2
3
4
5
6
7
#if define(__cplusplus)&& __cplusplus>=201103L
#ifndef _GXX_NULLPTR_T
#define _GXX_NULLPTR_T
typedef decltype(nullptr) nullptr_t

// ...
#endif

auto

在类型繁琐以及无法确定返回参数类型时使用(lambda function)

code

1
2
3
4
5
6
vector<string> v;
auto pos=v.begin();// 类型写起来繁琐
auto i=[](int x)->bool{ // lambda

};