1
template<typename T>
2
void swap(T a, T b){
3
    cout <<"T swap" << endl;
4
}
5

6
template<typename T>
7
void swap(vector<T> a, vector<T> b){ //针对vector类型提供的特化版本。
8
    cout <<"vector T swap" << endl;
9
}
10

11
int main(){
12
    vector<int> a{1,2,3,4};
13
    swap(1,2);
14
    swap(a, a);
15
    return 0;
16
}

1
template<typename InputIter>
2
void swap(InputIter a, InputIter b){
3
    cout <<"InputIter swap" << endl;
4
}
5
template<typename RandomAccessIter>
6
void swap(RandomAccessIter a, RandomAccessIter b){
7
    cout <<"RandomAccessIter swap" << endl;
8
}

1
//这部分迭代器分类套用标准库的一套。
2
struct my_input_iterator_tag {};
3
struct my_output_iterator_tag {};
4
struct my_forward_iterator_tag : public my_input_iterator_tag {};
5
struct my_bidirectional_iterator_tag : public my_forward_iterator_tag{};
6
struct my_random_access_iterator_tag : public my_bidirectional_iterator_tag {};
7

8
//这部分模拟某一种迭代器。
9
struct my_InputIter{
10
    using IterType =  my_input_iterator_tag; //迭代器里面有一个成员类型指明自己是哪一个迭代器类别。
11
};
12
struct my_RandomAccessIter{
13
    using IterType =  my_random_access_iterator_tag;
14
};
15

16
//迭代器类型萃取
17
template <typename Iter>
18
struct IterTraits{
19
    using IterType = typename Iter::IterType; //获取当前传入的迭代器的迭代器类别
20
};
21

22

23
template<typename Iterator>
24
void my_swapImpl(Iterator& x, Iterator& y){ //作为标签分派的转发函数。
25
    my_swap(x, y, typename IterTraits<Iterator>::IterType()); //细节注意，使用typename指明是类型后，使用()生成对应类型的匿名对象。
26
    //因为我们下面的标签是函数参数，需要一个对象。
27
}
28

29
template<typename InputIter> //对应的具体swap函数。
30
void my_swap(InputIter& a, InputIter& b, my_input_iterator_tag){ //第三个参数是tag。tag也是对象。
31
    cout <<"InputIter swap" << endl;
32
}
33

34
template<typename RandomAccessIter>
35
void my_swap(RandomAccessIter& a, RandomAccessIter& b, my_random_access_iterator_tag){
36
    cout <<"RandomAccessIter swap" << endl;
37
}
38

39
int main(){
40

41
    my_RandomAccessIter r1;
42
    my_RandomAccessIter r2;
43
    my_InputIter i1;
44
    my_InputIter i2;
45

46
    my_swapImpl(r1, r2);
47
    my_swapImpl(i1, i2);
48

49
    return 0;
50
}

1
template<typename Iter> //变量模板。判断是否是random迭代器。这里有细节。为什么要用is_convertible而不用is_same?
2
constexpr bool IsRandomAccessIter = is_convertible<typename IterTraits<Iter>::IterType, my_random_access_iterator_tag>::value;
3

4
template<typename Iter> //如果是random
5
typename enable_if<IsRandomAccessIter<Iter>>::type process(Iter& a, Iter& b){
6
    cout <<"IS random access iter" << endl;
7
}
8
template<typename Iter> //如果不是random
9
typename enable_if<!IsRandomAccessIter<Iter>>::type process(Iter& a, Iter& b){
10
    cout <<"NOT random access iter" << endl;
11
}
12
int main(){
13
    cout << boolalpha;
14
    my_RandomAccessIter r1;
15
    my_RandomAccessIter r2;
16
    my_InputIter i1;
17
    my_InputIter i2;
18
    process(i1, i1);
19
    process(r1, r2);
20
    return 0;
21
}

1
template<typename T1, typename T2>
2
class HasLess {
3
    template<typename T> struct Identity; //细节1
4

5
    template<typename U1, typename U2>
6
    static std::false_type test(...);
7

8
    template<typename U1, typename U2>
9
    static std::true_type test(Identity<decltype(declval<U1>() < declval<U2>())>*); //细节2
10

11

12
    public:
13
    static constexpr bool value = decltype(test<T1, T2>(nullptr))::value;
14
};

1
template<typename T1, typename T2>
2
class AnotherHasLess {
3
    template<typename T> struct Identity{}; //细节1
4

5
    template<typename U1, typename U2>
6
    static std::false_type test(...);
7

8
    template<typename U1, typename U2, typename = decltype(Identity<decltype(declval<U1>() < declval<U2>())>())>  //细节2
9
    static std::true_type test(void*);
10

11
    public:
12
    static constexpr bool value = decltype(test<T1, T2>(nullptr))::value;
13
};

1
template<typename T1, typename T2>
2
class MoreHasLess {
3
    static bool try_call(bool); //细节1
4
    template<typename U1, typename U2>
5
    static std::false_type test(...);
6

7
    template<typename U1, typename U2, typename = decltype(try_call(declval<U1>() < declval<U2>()))>  //细节2
8
    static std::true_type test(void*);
9

10
    public:
11
    static constexpr bool value = decltype(test<T1, T2>(nullptr))::value;
12
};

1
template<typename T>
2
class Base{
3

4
};
5

6
class Derive: public Base<Derive>{
7

8
};

1
template <typename T>
2
class Base{
3
    public:
4
        void func(){ //注意这个不是虚函数。不是动态多态
5
            static_cast<T*>(this)->func(); //使用static_cast转换为子类指针
6
        }
7
};
8
class myclass:public Base<myclass>{
9
    public:
10
        void func(){
11
            cout <<"called" << endl;
12
        }
13
};
14

15
int main(){
16
    Base<myclass>* obj = new myclass;
17
    obj->func();
18
}

1
class printBase{
2
    public:
3
        virtual void print_val() = 0;
4
};
5
class printMethod1 : public virtual printBase{
6
    public:
7
        void my_print(){
8
            cout <<"method1" << endl;
9
        }
10
        void print_val(){
11
            my_print();
12
        }
13
};
14
class printMethod2 : public virtual printBase{
15
    public:
16
        void my_print(){
17
            cout <<"method2" << endl;
18
        }
19
        void print_val(){
20
            my_print();
21
        }
22
};
23
class I_want_all:public printMethod1, printMethod2{
24
    public:
25
        void print_val(){
26
            printMethod1::my_print();
27
        }
28
        void print_method1(){
29
            print_val();
30
        }
31
        void print_method2(){
32
            printMethod2::my_print();
33
        }
34
};
35
int main(){
36
    I_want_all obj;
37
    obj.print_method1();
38
    obj.print_method2();
39
}

1
template<typename T>
2
class printMethod1 : public T{
3
    public:
4
        void my_print(){
5
            cout <<"method1" << endl;
6
            T::my_print();
7
        }
8
};
9

10
template<typename T>
11
class printMethod2 : public T{
12
    public:
13
        void my_print(){
14
            cout <<"method2" << endl;
15
            T::my_print();
16
        }
17
};
18

19
class myclass{
20
    public:
21
        void my_print(){
22
            cout <<"my print" << endl;
23
        }
24
};
25

26
int main(){
27
    myclass obj;
28
    obj.my_print();
29
    cout<<"-----------------------"<<endl;
30
    printMethod1<myclass> obj2;
31
    obj2.my_print();
32
    cout<<"-----------------------"<<endl;
33
    printMethod2<myclass> obj3;
34
    obj3.my_print();
35
    cout<<"-----------------------"<<endl;
36
    printMethod1<printMethod2<myclass>> obj4;
37
    obj4.my_print();
38
    cout<<"-----------------------"<<endl;
39
    printMethod2<printMethod1<myclass>> obj5;
40
    obj5.my_print();
41
}
42
/*
43
my print
44
-----------------------
45
method1
46
my print
47
-----------------------
48
method2
49
my print
50
-----------------------
51
method1
52
method2
53
my print
54
-----------------------
55
method2
56
method1
57
my print
58
*/

1
template<typename... Mixin>
2
class PointMixin : public Mixin...{
3
    public:
4
        PointMixin() = default;
5
        PointMixin(int x, int y): Mixin()..., posx(x), posy(y){} //Mixin()...是一个参数包展开。作用是调用所有继承来的类的默认构造。这里最好调用一下。养成好习惯。虽然此处不调用也没差。
6
        int posx = 0;
7
        int posy = 0;
8
};
9
class color{
10
    public:
11
        color(){
12
            cout <<"color const called" << endl;
13
        }
14
        int colorID = 234;
15
        void colorfunc(){
16
            cout <<"color" << endl;
17
        }
18
};
19

20
class label{
21
    public:
22
        label(){
23
            cout <<"label const called" << endl;
24
        }
25
        char charId = 'a';
26
        void labelfunc(){
27
            cout <<"label" << endl;
28
        }
29
};
30
int main(){
31
    PointMixin<color, label> obj;
32
    obj.labelfunc();
33
    obj.colorfunc();
34
}

1
template<typename... Mixins>
2
class containerMixins{
3
    public:
4
        vector<PointMixin<Mixins...>> myvec;
5
};
6
int main(){
7
    PointMixin<color, label> obj;
8
    containerMixins<color, label> mycontainer;
9
    mycontainer.myvec.push_back(obj);
10
    mycontainer.myvec[0].labelfunc();
11
    mycontainer.myvec[0].colorfunc();
12
}

1
struct myobj{ //重载了函数调用运算符的类
2
    void operator()(int x){
3
        cout << "called" << x << endl;
4
    }
5
};
6
void func(int x){ //函数指针
7
    cout << "called" << x << endl;
8
}
9

10

11
template<typename F>
12
void test(int x, F f){ //调用
13
    std::puts(__PRETTY_FUNCTION__);
14
    f(x);
15
}
16

17

18
int main(){
19
    auto mylambda = [](int x){cout <<"called" << x << endl;}; //lambda
20
    test(10, mylambda);
21
    test(20, func);
22
    test(30, myobj());
23
}

1
void test(int, F) [with F = main()::<lambda(int)>]
2
called10
3
void test(int, F) [with F = void (*)(int)]
4
called20
5
void test(int, F) [with F = myobj]
6
called30

1
template<typename... Items>
2
class typeList{}; //类型列表 主类 。你没看错，就这么简单
3

4
//-----获取第一个元素------
5
template<typename Items> //Item代表了整个typeList。所以此处不需要变参。
6
class FrontItem{}; //获取第一个元素的主模板。
7

8
//因为我们整个塞进去的是typeList。所以我们下面的特化是基于typeList里面的参数的。
9
template<typename First, typename... Other>
10
class FrontItem<typeList<First, Other...>>{ //偏特化，把元素按照第一个和其余的拆开。
11
    public:
12
        using type = First; //只保留第一个元素
13
};
14
//-----移除第一个元素------
15
template <typename Items> //此处同FrontItem
16
class PopFront{}; //移除第一个元素
17

18
template<typename First, typename... Other> //此处同FrontItem
19
class PopFront<typeList<First, Other...>>{
20
    public:
21
    using type = typeList<Other...>; //去掉第一个元素，成为新的typelist
22
};
23
//-----获取typelist的大小------
24
template<typename Items>
25
class ListSize{}; //获取类型列表的大小。此处同FrontItem
26

27
template<typename... Items> //因为我们不再需要拆开了，所以不需要First模板形参了。
28
class ListSize<typeList<Items...>>{
29
    public:
30
    static inline size_t value = sizeof...(Items);
31
};
32

33
//-----头部插入元素------
34
template<typename Items, typename NewItem> //此处同FrontItem, Items是整个typelist, NewItem是新的元素（类型）。
35
class PushFront{}; //头插
36

37
template<typename... Items, typename NewItem> //和pop相反
38
class PushFront<typeList<Items...>, NewItem>{ //和pop相反
39
    public:
40
        using type = typeList<NewItem, Items...>; //直接组合成新的typelist
41
};
42

43
//-----尾部插入元素------
44
template<typename Items, typename NewItem> //此处同FrontItem, Items是整个typelist, NewItem是新的类型。
45
class PushBack{}; //尾插
46

47
template<typename... Items, typename NewItem> //和头插相同
48
class PushBack<typeList<Items...>, NewItem>{ //和头插相同
49
    public:
50
        using type = typeList<Items..., NewItem>; //直接组合成新的typelist，只是和头插顺序相反。
51
};
52

53
//-----替换第一个元素------
54
template<typename Items, typename ReplaceItem>
55
class ReplaceFront{}; //替换第一个元素。
56

57
template<typename First, typename... Other ,typename ReplaceItem> //注意这里有三个元素。第一个，剩下的和替换的。
58
class ReplaceFront<typeList<First, Other...>, ReplaceItem>{
59
    public:
60
        using type = typeList<ReplaceItem, Other...>; //直接把第一个换成替换的即可。
61
};
62

63
//-----判断是否为空------
64
template<typename Items>
65
class isEmpty{ //判断是否为空。
66
    public:
67
        static inline const bool value = false;
68
};
69

70
template<>
71
class isEmpty<typeList<>>{ //直接全特化。如果列表为空直接匹配过来。
72
    public:
73
        static inline const bool value = true;
74
};
75

76
//-----真正的typelist-----
77
using Typelist1 = typeList<int, char, string, double, float>; //类型列表
78
using emptylist = typeList<>;//空的类型列表
79

80
int main(){
81
    cout << boolalpha;
82
    cout << typeid(FrontItem<Typelist1>::type).name() << endl; //输出类型列表第一个元素的类型。int
83
    cout << ListSize<Typelist1>::value << endl;//输出类型列表的大小。5
84

85
    cout << typeid(FrontItem<PopFront<Typelist1>::type>::type).name() << endl; //先把类型列表的第一个元素去掉，然后输出第一个元素类型。char。记住，我们针对所有原始类型列表的操作，都不是作用于原始列表。都是新建列表。
86
    cout << ListSize<PopFront<Typelist1>::type>::value<<endl; //获取移除第一个元素后的列表大小。4
87

88
    cout << typeid(FrontItem<Typelist1>::type).name() << endl; //获取原始类型列表的第一个元素，证明操作不作用于原始列表。int
89

90
    using pushedback = PushBack<Typelist1, int>::type; //使用别名方便使用。这个操作是在类型列表尾部插入新的类型int
91
    cout << ListSize<pushedback>::value<<endl; //插入后，新列表大小。6（原来是5）
92

93
    using pushedfront = PushFront<pushedback, double>::type; //在尾插后的类型列表头插double
94
    cout << ListSize<pushedfront>::value<<endl;//新列表大小7
95

96
    using replaced_front = ReplaceFront<Typelist1, float>::type; //把类型列表首元素换位float
97
    cout << typeid(FrontItem<replaced_front>::type).name() << endl; //新列表首元素 float
98

99

100
    cout << isEmpty<Typelist1>::value << endl; //是否为空，否
101
    cout << isEmpty<emptylist>::value << endl; //是否为空，是
102
    return 0;
103

104
}

1
template<typename Items, unsigned int m_index> //item是个typelist，m_index是索引
2
class find_element: public find_element<typename PopFront<Items>::type, m_index-1>{};
3
//这里面用了递归，每次都继承自把首元素去掉的typelist。注意需要使用type因为那才是我们定义的typelist。并且加typename显式指明是类型。然后index-1
4

5
template<typename Items>//这个是针对找到了对应index的特化。因为index最终会减到0。这时候的特化版本继承自FrontItem，因为这个时候typelist的首元素就是我们想要找的那个元素。
6
class find_element<Items, 0>: public FrontItem<Items>{};
7

8

9
cout << typeid(find_element<Typelist1, 3>::type).name() << endl; //输出double