1
template <typename T>
2
void func(T a){ //主模板
3
    cout <<"main" << endl;
4
}
5
template <typename T>
6
void func(T* a){ //重载模板
7
    cout << "overload" << endl;
8
}
9
int main(){
10
    int* p;
11
    func(p); //输出overload
12
}
13
//注意，调用的时候，如果调用第一个，因为传入的是int*，所以第一个里面的T会被推导为int*
14
//如果调用第二个，因为传入的是int*, 而里面又已经有了个*所以T就只被推导为int。

1
template<typename T>            // (1) - 主模板
2
string getTypeName(T){
3
    return "unknown";
4
}
5

6
template<typename T>            // (2) - 重载自 (1) 的主模板。 针对指针类型的模板重载
7
string getTypeName(T*){
8
    return "pointer";
9
}
10

11
template<>                      // (3) - (2) 的显式全特化。针对int指针类型的显式全特化
12
string getTypeName(int*){
13
    return "int pointer";
14
}
15

16
// getTypeName2
17

18
template<typename T>            // (4) - 主模板
19
string getTypeName2(T){
20
    return "unknown";
21
}
22

23
template<>                      // (5) - (4) 的显式全特化。 针对int指针类型的显式全特化
24
string getTypeName2(int*){
25
    return "int pointer";
26
}
27
template<typename T>            // (6) - 重载自 (4) 的主模板。 针对指针类型的模板重载
28
string getTypeName2(T*){
29
    return "pointer";
30
}
31

32
int main(){
33

34
    cout << '\n';
35
    int* p;
36
    cout << "getTypeName(p): " << getTypeName(p) <<  '\n';
37
    //输出getTypeName(p): int pointer
38
    cout << "getTypeName2(p): " << getTypeName2(p) <<  '\n';
39
    //输出getTypeName2(p): pointer
40
    cout <<  '\n';
41

42
}

1
template<typename T>            // (7) - 主模板
2
string getTypeName3(T){
3
    return "unknown";
4
}
5

6
template<>                      // (8) - (7) 的显式全特化。 针对int指针类型的显式全特化
7
string getTypeName3(int*){
8
    return "int pointer";
9
}
10
template<typename T>            // (9) - 重载自 (7) 的主模板。 针对指针类型的模板重载
11
string getTypeName3(T*){
12
    return "pointer";
13
}
14
template<>                      // (10) - (9) 的显式全特化。 针对int指针类型的显式全特化
15
string getTypeName3(int*){
16
    return "another int pointer";
17
}
18
int main(){
19

20
    cout << '\n';
21
    int* p;
22
    int a = 0;
23
    cout << "getTypeName3(p): " << getTypeName3(p) <<  endl;   //输出another int pointer
24
    cout << "getTypeName3(a): " << getTypeName3(a) << endl; //输出 unknown
25
    // cout <<  '\n';
26

27
}

1
template <class T>
2
void testf(T); //注意，这里没有定义！！
3
template <>
4
void testf(int) {
5
    //一些内容
6
}
7
int main(){
8
    testf(3);//可以
9
    testf(3.3); //不行
10
    return 0;
11
}

1
template<typename T>
2
void func(T const&);
3

4
func(42);   //  void func<> (int const&);
5
func('a');   //   void func<> (char const&);

1
#include <iostream>
2

3
int main()  {
4
    std::cout << "Hello world!" << std::endl;
5
}

1
template <class T>
2
class MyClass {
3
    int i;
4
    vector<int> vi;
5
    vector<int>::iterator vitr;
6

7
    T t;
8
    vector<T> vt;
9
    vector<T>::iterator viter;
10
};

1
class test{
2
    public:
3
    class testinner{ //嵌套类
4
        public:
5
        int _val;
6
        testinner(){}
7
        testinner(int x):_val(x){}
8
    };
9
    test(){}
10
    typedef int testdef;
11

12

13
    int s;
14
};
15

16
int main()
17
{
18
    test::testinner tt1 = test::testinner(5); //OK
19
    test::testinner tt2; //OK 访问嵌套类
20
    test::testdef tt3 = 5; //OK 访问typedef。
21
    test::s = 5; //不行。直接访问的成员必须是静态成员。
22
    test t;
23
    t.test::s = 5; //OK 通过对象访问，但是还是脱裤子放屁加了作用域解析运算符。
24

25
    return 0;
26
}

1
class test{
2
    public:
3
        struct obj{
4
            int _sb;
5
        };
6
        obj s;
7
        int _val;
8
        test(){}
9
        test(int x):_val(x){}
10
        test(int x, int y){
11
            _val = x;
12
            s._sb = y;
13
        }
14
};
15
template<typename T>
16
void func(){
17
    test t(5,8);
18
    typename T::obj* ptr = &t.s;
19
    //这里我们的意思是有一个指针ptr指向了T类里面的obj类型的对象。翻译成人话也就是ptr是一个T::obj类型的指针。但是如果有一个T类里面的obj是一个变量，如static int obj = 8
20
    //那么这就变成了变量乘法。会有歧义。所以使用typedef显式告知编译器 T::obj不是一个变量，而是一个类型。
21
    cout << ptr->_sb << endl;
22
}

1
typedef iterator_traits<T>::value_type value_type_anothername;
2
//这句话的意思是value_type_anothername是在模板类iterator_traits中的 变量 value_type的别名。
3

4
//所以如果有
5
value_type_anothername name = "foward_iterator";
6
//这样是不行的。因为value_type_anothername是一个变量不是类型。
7
//所以我们需要加typedef告知编译器这个是类型
8

9
typedef typename iterator_traits<T>::value_type value_type_anothername;
10
//这句话的意思是value_type_anothername是iterator_traits<T>::value_type这个 类型 的别名。
11

12
//所以这样可以有
13
value_type_anothername name = "foward_iterator";
14
//因为value_type_anothername 是个类型。就好比int string这种。

1
class test{
2
    public:
3
    typedef int inputtype;
4
};
5

6
int main(){
7
    test::inputtype x = 4; //这句话等于告诉你 test类下面的inputtype这个东西是int
8
}

1
class test{
2
    public:
3
    test(){}
4
    typedef int inputtype;
5
};
6

7

8
template<typename T>
9
class test1{
10
    public:
11
    test1(){};
12
    typedef typename T::inputtype inputtype; //注意这里，T::inputtype是个类型。比如test::inputtype 就是 int类型
13
};

1
struct foo {
2
    foo() = default; // 去掉会无法编译。
3
    // 我们有用户定义的构造函数, 所以编译器不会隐式生成默认构造函数。所以去掉会无法编译。
4
    template<typename T>
5
    foo(){
6
        cout <<"ctor" << endl;
7
    }
8
};

1
f(expression);
2
wrapperf(expression);

1
void f(const vector<int>& t){ //目标函数
2
    cout <<"called" << endl;
3
}
4

5
template<typename... T>
6
void wrapperf(T&&... args){ //转发函数
7
    f(forward<T>(args)...);
8
}
9

10

11
int main(){
12
    f({1,2,3,4,5}); // OK
13
    wrapperf({1,2,3,4,5}); // 不行
14
    return 0;
15
}

1
void f(int(*pf)(int)){ //目标函数
2
    pf(100);
3
}
4

5
template<typename... T>
6
void wrapperf(T&&... args){ //转发函数
7
    f(forward<T>(args)...);
8
}
9

10
int testfunc(int a){
11
    cout <<"testfunc" << endl;
12
    return 10;
13
}
14
int testfunc(int a, int b){
15
    cout <<"testfunc overload" << endl;
16
    return 20;
17
}
18

19
int main(){
20
    f(testfunc); // OK
21
    wrapperf(testfunc); //不行
22
    return 0;
23
}

1
template<typename T, typename ret>
2
void testextractmember1(ret (T::*pf)){
3
    std::puts(__PRETTY_FUNCTION__);
4
}
5

6
template<typename T, typename ret>
7
void testextractmember2(ret T::*pf){
8
    std::puts(__PRETTY_FUNCTION__);
9
}
10

11
testextractmember1(&obj::sb);
12
testextractmember2(&obj::sb);
13
testextractmember1(&obj::func3);
14
testextractmember2(&obj::func3);
15

16
//void testextractmember1(ret T::*) [with T = obj; ret = int]
17
//void testextractmember2(ret T::*) [with T = obj; ret = int]
18
//void testextractmember1(ret T::*) [with T = obj; ret = bool(int)]
19
//void testextractmember2(ret T::*) [with T = obj; ret = bool(int)]

1
template<typename ret, typename T>
2
void diff(ret(T::*pf)){ //成员指针
3
    cout <<"called variable" << endl;
4
}
5
int main(){
6
    diff(&obj::val); //called variable
7
    diff(&obj::func2); //called variable
8
    diff(&obj::func3);//called variable 注意带参数的也可以
9
}

1
template<typename ret, typename T>
2
void diff(ret(T::*pf)()){ //成员函数指针
3
    cout <<"called func" << endl;
4
}
5

6
int main(){
7
    diff(&obj::val); //报错
8
    diff(&obj::func2);
9
  diff(&obj::func3);//报错
10
}

1
template<typename ret, typename T>
2
void diff(ret(T::*pf)){
3
    cout <<"called variable" << endl;
4
}
5
template<typename ret, typename T>
6
void diff(ret(T::*pf)()){
7
    cout <<"called func" << endl;
8
}
9
int main(){
10
    diff(&obj::val);  //called variable
11
    diff(&obj::func2);  //called func
12
    diff(&obj::func3);   //called variable 格外注意这里匹配的问题
13

14
}

1
template <typename T>
2
struct GetRet { //主模板，如果内部含有operator()就取它的类型
3
    private:
4
        using DT = std::decay_t<T>;
5
    public:
6

7
        using type = typename GetRet<decltype(&DT::operator())>::type;  //比较特殊，因为decltype(&DT::operator())是获取成员函数指针类型。在杂记4中提到过。然后递归调用
8
        using type1 = decltype(declval<T>()()); //展开是这样declval<T>().operator()()
9

10
        void pivot(){
11
            std::puts(__PRETTY_FUNCTION__);
12
            std::cout << std::is_same_v<decltype(&DT::operator()), int(T::*)()>; // true 注意是成员函数指针类型
13
            std::cout << std::endl;
14
        }
15
};
16

17
// 函数类型的特化
18
template <typename R, typename... Args>
19
struct GetRet<R(Args...)> {
20
    using type = R;
21
    void pivot(){
22
            std::puts(__PRETTY_FUNCTION__);
23
    }
24
};
25

26
// 函数指针类型的特化
27
template <typename R, typename... Args>
28
struct GetRet<R(*)(Args...)> {
29
    using type = R;
30
    void pivot(){
31
            std::puts(__PRETTY_FUNCTION__);
32
    }
33
};
34

35
// 非静态成员函数指针类型的特化
36
template <typename T, typename R, typename... Args>
37
struct GetRet<R(T::*)(Args...)> {
38
    using type = R;
39
    void pivot(){
40
            std::puts(__PRETTY_FUNCTION__);
41
    }
42
};
43
// const非静态成员函数指针类型的特化
44
template <typename T, typename R, typename... Args>
45
struct GetRet<R(T::*)(Args...) const> {
46
    using type = R;
47
    void pivot(){
48
            std::puts(__PRETTY_FUNCTION__);
49
    }
50
};
51

52
template <typename T>
53
using GetRet_t = typename GetRet<T>::type;
54

55
// 测试用例
56
int f() {           //普通函数
57
    return 0;
58
}
59
struct T1 {             //非静态成员函数
60
    int mem_func(){
61
        cout <<"T1 mem_func" << endl;
62
        return 0;
63
    }
64
};
65

66
struct T2 {
67
    int operator()(){ //operator()
68
        cout <<"T2 ()" << endl;
69
        return 0;
70
    }
71
};
72

73
int main() {
74
    GetRet_t<decltype(f)> a;    // 函数类型
75

76
    GetRet_t<decltype(&f)> b;   // 函数指针类型
77

78
    GetRet_t<T2> c;             // 函数对象类型 -- 仿函数
79

80
    auto lamb = []()->int{return 0;};   // lambda类型
81
    GetRet_t<decltype(lamb)> d;
82

83
    GetRet_t<decltype(&T1::mem_func)> e; // 非静态成员函数类型
84

85
    GetRet_t<std::function<int()>> g;   //函数对象类型 -- std::function对象
86

87
    std::cout << std::is_same_v<std::decay_t<decltype(a)>, int>; // true
88
    std::cout << std::is_same_v<std::decay_t<decltype(b)>, int>; // true
89
    std::cout << std::is_same_v<std::decay_t<decltype(c)>, int>; // true
90
    std::cout << std::is_same_v<std::decay_t<decltype(d)>, int>; // true
91
    std::cout << std::is_same_v<std::decay_t<decltype(e)>, int>; // true
92
    std::cout << std::is_same_v<std::decay_t<decltype(g)>, int>; // true
93
    std::cout << std::is_same_v<decltype(declval<T2>()()), int>; // true
94
    std::cout << std::endl;
95

96
    GetRet<decltype(f)> x1;
97
    GetRet<decltype(&f)> x2;
98
    GetRet<T2> x3;
99
    GetRet<decltype(lamb)> x4;
100
    GetRet<decltype(&T1::mem_func)> x5;
101
    GetRet<std::function<int()>> x6;
102
    x1.pivot();
103
    x2.pivot();
104
    x3.pivot();
105
    x4.pivot();
106
    x5.pivot();
107
    x6.pivot();
108
/*
109
void GetRet<R(Args ...)>::pivot() [with R = int; Args = {}]
110
void GetRet<R (*)(Args ...)>::pivot() [with R = int; Args = {}]
111
void GetRet<T>::pivot() [with T = T2]
112
void GetRet<T>::pivot() [with T = main()::<lambda()>]
113
void GetRet<R (T::*)(Args ...)>::pivot() [with T = T1; R = int; Args = {}]
114
void GetRet<T>::pivot() [with T = std::function<int()>]
115
*/
116
}