1
template<typename T, static int MAXSIZE> //例子1，错误。不能有static
2
void func1(T obj){
3

4
}

1
template<const int length> class Buffer; //二者相同。因为最顶层CV限定会被忽略
2
template<int length> class Buffer;

1
template<typename T1, typename T2, typename T3, typename T4, typename T5> //可以，每一个都没有默认实参
2
class myclass;
3
template<typename T1, typename T2, typename T3, typename T4 = int, typename T5 = int> //可以，从T4开始每一个都有默认实参
4
class myclass;
5
template<typename T1, typename T2, typename T3 = int, typename T4, typename T5> //可以，由于T4和T5在上面的声明中已有默认实参，所以在这里是T3后的都有默认实参
6
class myclass{
7
    public: //只有一个定义
8
        void func(){
9
            std::puts(__PRETTY_FUNCTION__);
10
        }
11
};
12
//----以下是错误例子
13
template<typename T1 = char, typename T2, typename T3, typename T4, typename T5> //错误。T1后的参数都没有默认实参
14
class myclass;

1
template<typename T1 = int, typename T2, typename T3 = float, typename T4 = char, typename T5>
2
void func(T1, T2, T3, T4, T5){
3
    std::puts(__PRETTY_FUNCTION__);
4
}
5
/*
6
void func(T1, T2, T3, T4, T5) [with T1 = int; T2 = int; T3 = float; T4 = char; T5 = char]
7
*/

1
template <typename T>
2
class Base{
3
    public:
4
        int baseval;
5
        using Type = int;
6
};
7

8

9
class D1:public Base<double>{ //非依赖名基类。
10
    public:
11
        void func(){
12
            baseval = 200;
13
        }
14
        Type D1val = 300;
15
};
16

17

18
int main(){
19
    D1 obj;
20
    obj.func();
21
    cout << obj.baseval << obj.D1val << endl;
22
}

1
template <typename T> //主模板
2
struct ElementType;
3

4
template <typename T>
5
struct ElementType<vector<T>>{ //针对vector类型的偏特化
6
    using Type = T;
7
};
8

9
template <typename T>
10
struct ElementType<list<T>>{ //针对list类型的偏特化
11
    using Type = T;
12
};
13

14
template <typename T>
15
struct ElementType<deque<T>>{ //针对deque类型的偏特化
16
    using Type = T;
17
};
18
//.....其他容器类型
19
template<typename T>
20
void printType(const T& container){
21
    std::puts(__PRETTY_FUNCTION__);
22
    cout << typeid(typename ElementType<T>::Type).name() << endl; //打印元素类型
23
}
24

25
int main(){
26
    vector<int> vec_a;
27
    vector<bool> vec_b;
28
    deque<char> deq_a;
29
    list<double> list_a;
30
    printType(vec_a);
31
    printType(vec_b);
32
    printType(deq_a);
33
    printType(list_a);
34

35
    return 0;
36
};

1
template <typename T>
2
struct ElementType{ //针对提供了value_type或没有写入偏特化的类型的 默认实现
3
    using Type = typename T::value_type;
4
};
5

6
template <>
7
struct ElementType<myobj>{ //针对myobj类型的特化。
8
    using Type = int;
9
};

1
template<typename T, typename C>
2
T sumOfElements (C const& c);

1
template<typename C>
2
typename ElementType<C>::Type sumOfElements (C const& c);

1
template<typename T>
2
using a_ElementType = typename ElementType<T>::Type; //别名模板
3

4
template<typename C>
5
a_ElementType<C> sumOfElements (C const& c){
6
    cout <<"called" << endl;
7
}

1
template<typename T>
2
vector<T> add(const vector&<T> vec1, const vector<T>& vec2);

1
class wtf{
2
    public:
3
    int val;
4
    wtf() = default;
5
    wtf(int x):val(x){};
6
    wtf operator+(const wtf& rhs) const{ //细节1
7
        cout <<"wtf+" << endl;
8
        return wtf(val + rhs.val);
9
    }
10
};
11

12
template<typename T1, typename T2>
13
struct VecPlusTrait{ //返回值类型萃取
14
    using Type = decltype(T1() + T2()); //细节2
15
};
16

17
template<typename T1, typename T2>
18
vector<typename VecPlusTrait<T1, T2>::Type> operator+(const vector<T1>& vec1, const vector<T2>& vec2 ){
19
    if(vec1.size() != vec2.size()){
20
        return {};
21
    }
22
    vector<typename VecPlusTrait<T1, T2>::Type> myvec;
23
    myvec.reserve(vec1.size());
24
    for(int i = 0; i < vec1.size(); i++){
25
        myvec.emplace_back(vec1[i] + vec2[i]);
26
    }
27
    return myvec;
28
}
29

30
int main(){
31
    vector<wtf> vec1{1,2,3,4,5,6,7};
32
    vector<wtf> vec2{2,3,4,5,6,7,8};
33
    auto ret = vec1+vec2;
34
    for(auto& i:ret){
35
        cout <<i.val << endl;
36
    }
37
    return 0;
38
};

1
template<typename T1, typename T2>
2
vector<typename std::decay<typename VecPlusTrait<T1, T2>::Type>::type> operator+(const vector<T1>& vec1, const vector<T2>& vec2 ){ //使用decay
3
    if(vec1.size() != vec2.size()){
4
        return {};
5
    }
6
    vector<typename std::decay<typename VecPlusTrait<T1, T2>::Type>::type> myvec; /使用decay
7
    myvec.reserve(vec1.size());
8
    for(int i = 0; i < vec1.size(); i++){
9
        myvec.emplace_back(vec1[i] + vec2[i]);
10
    }
11
    return myvec;
12
}

1
template<typename T1, typename T2>
2
struct VecPlusTrait{
3
    using Type = decltype(declval<T1>() + declval<T2>());
4
};

1
template<typename T>
2
struct ChectIsDefaultConstructible{
3
    private:
4
        template<typename U, typename = decltype(U())> //细节1
5
        static char check(void*); //细节2
6

7
        template<typename>
8
        static int check(...); //细节3
9

10
    public:
11
        static constexpr bool value = is_same<decltype(check<T>(nullptr)), char>::value; //细节4
12
};
13
int main() {
14
    cout <<std::boolalpha;
15
    cout << ChectIsDefaultConstructible<myclass>::value << endl;
16
    return 0;
17
}

1
template<typename T, typename = void> //原因不解释了。都在void_t章节
2
struct ChectIsDefaultConstructible : false_type{};  //主模板默认是false_type
3
template<typename T>
4
struct ChectIsDefaultConstructible<T, void_t<decltype(T())>> : true_type{};
5

6
int main() {
7
    cout <<std::boolalpha;
8
    cout << ChectIsDefaultConstructible<myclass>::value << endl;
9
    return 0;
10
}

1
struct A {
2
    using mytype = int; //类A含有mytype类型
3
};
4

5
struct B{
6
    using mytype = void; //类B也含有mytype类型
7
};
8

9

10
template<typename T1 , typename T2 = void > //主模板，第二个参数默认值是void，非常重要
11
struct has_type_member : std::false_type { //主模板继承false_type
12

13
 };
14

15
template<typename T1> //针对第二个参数进行偏特化
16
struct has_type_member<T1, std::void_t<typename T1::mytype>>: std::true_type { //偏特化继承true_type，并且使用void_t进行类型判断。
17
};
18

19
int main(){
20
    auto a = has_type_member<A>::value;
21
    auto b = has_type_member<B>::value;
22
    cout << a << endl;
23
    cout << b << endl;
24
    auto c = has_type_member<A&>::value; //注意这两个
25
    auto d = has_type_member<B&>::value; //注意这两个
26
    cout << c << endl;
27
    cout << d << endl;
28
}

1
template<typename T1 , typename T2 = void >
2
struct has_type_member : std::false_type {
3

4
 };
5
template<typename T1> //针对第二个参数进行偏特化
6
struct has_type_member<T1, std::void_t<typename remove_reference<T1>::type::mytype>>: std::true_type { //偏特化继承true_type，并且使用void_t进行类型判断。
7
};

1
#define DEFINE_HAS_TYPE(MemType)\
2
template<typename, typename = void>\
3
struct HasTypeT_##MemType : std::false_type{};\
4
template<typename T>\
5
struct HasTypeT_##MemType<T, std::void_t<typename T::MemType>> : std::true_type{} // 注意没有分号！
6
struct A{
7
    using mytype = int;
8
};
9

10
struct B{
11
    using anothertype = float;
12
};
13
DEFINE_HAS_TYPE(mytype); //我们上面故意去掉的分号原因是这里是那个分号。
14
DEFINE_HAS_TYPE(anothertype);
15
int main(){
16
    cout << boolalpha;
17
    cout << HasTypeT_mytype<A>::value << endl;
18
    cout << HasTypeT_mytype<B>::value << endl;
19
    cout << HasTypeT_anothertype<A>::value << endl;
20
    cout << HasTypeT_anothertype<B>::value << endl;
21
}

1
struct A {
2

3
};
4

5
struct B{
6
    bool operator <(A o1){ //B和A的小于操作
7
    }
8
};
9
bool operator <(int, A o1){ //int和A的小于操作
10

11
}
12

13
template<typename T1 , typename T2, typename = void >
14
struct has_less_operation:std::false_type {
15

16
 };
17

18
template<typename T1, typename T2>
19
struct has_less_operation<T1, T2, std::void_t<decltype(declval<T1>() < declval<T2>())>>: std::true_type { //判断是否有小于操作
20
};
21
int main(){
22
    cout <<std::boolalpha;
23
    cout << has_less_operation<int, int>::value << endl;
24
    cout << has_less_operation<string, string>::value << endl;
25
    cout << has_less_operation<B, A>::value << endl;
26
    cout << has_less_operation<int, A>::value << endl;
27

28
    cout << has_less_operation<string, int>::value << endl;
29
    cout << has_less_operation<A, B>::value << endl;
30

31
    /*
32
    输出
33
    true
34
    true
35
    true
36
    true
37
    false
38
    false
39
    */
40
}

1
template<bool cond, typename TypeIfTrue, typename TypeIfFalse>
2
struct IfthenElse{
3
    using Type = TypeIfFalse;
4
};
5

6
template<typename TypeIfTrue, typename TypeIfFalse>
7
struct IfthenElse<true, TypeIfTrue, TypeIfFalse>{
8
    using Type = TypeIfTrue;
9
};
10

11
int main() {
12
    IfthenElse<(sizeof(int) >= 4), int, double>::Type a;
13
    cout << boolalpha;
14
    cout << is_same<int, decltype(a)>::value << endl; //true
15
}

1
template<bool check = false> //默认是false
2
struct bool_extraction{
3
    using value = false_type;
4
    void func(){
5
        cout <<"false" << endl;
6
    }
7
};
8
template<>
9
struct bool_extraction<true>{ //true的偏特化。
10
    using value = true_type;
11
    void func(){
12
        cout <<"true" << endl;
13
    }
14
};