1
class tmp{
2
    public:
3
    string _text;
4
    tmp(string c): _text(c) {}
5

6
};
7
class test{
8
    public:
9
    string _text;
10
    test(string a): _text(a){}
11
    /*explicit*/ test(tmp s): _text(s._text){} //test类的构造函数接受tmp类型的对象。
12
};
13

14
class twonumber{
15
    public:
16
    test ret(){
17
        test(tmp("cde"));
18
        return(tmp("abc")); //此处返回的对象是一个tmp，但是函数头的返回类型却是test。因为这里使用了构造函数的隐式转换。也就是test类的构造函数接受tmp类型的对象
19
        //!由于return语句内是隐式转换，所以对应的构造函数如果有explicit关键字则无法进行隐式转换。

1
int a = 3;
2
double b = 4.5;
3
a + b; // a将会被自动转换为double类型，转换的结果和b进行加法操作

1
int a = true ; ( bool 类型被转换为 int 类型)
2
int * ptr = null;（null被转换为 int *类型）

1
void func( double a);
2
func(1); // 1被隐式的转换为double类型1.0

1
double add( int a, int b)
2
{
3
return a + b;
4
} //运算的结果会被隐式的转换为double类型返回

1
#include <iostream>
2
#include <string>
3
#include<memory>
4
#include <queue>
5
#include <functional>
6
#include <algorithm>
7
using namespace std;
8

9
/*
10
text 我们的目的是传入一个数字X，让容器内的数字依据和X的差值进行排序。
11
*/
12
class mycomp{ //&priority_queue 的比较器
13
    public:
14
        bool operator()(int a, int b, int x){
15
            if(abs(a-x) >= abs(b-x)){
16
                return false;
17
            }
18
            return true;
19
        }
20
};
21
class mycomp1{ //&vector 的比较器。注意和优先队列是相反的。
22
    public:
23
        bool operator()(int a, int b, int x){
24
            if(abs(a-x) <= abs(b-x)){
25
                return false;
26
            }
27
            return true;
28
        }
29
};
30
void func(vector<int>& vec, int x){
31

32
    sort(vec.begin(), vec.end(), bind(mycomp1(), placeholders::_1, placeholders::_2, x)); //&使用bind对sort所需的自定义比较器参数进行绑定。
33

34
    auto cmp = [=](int a, int b) { return abs(a-x)< abs(b-x); };//&使用lambda做为自定义比较器
35
    priority_queue<int, vector<int>, decltype(cmp)> my_que{cmp}; //%注意，类型使用decltype自动推导，并且需要在优先队列构造函数内传入该比较器对象。
36
    //* 可以换成花括号。尤其是当要传入一个匿名对象的时候，防止语义问题。
37

38

39
    auto cmp1 = bind(mycomp(), placeholders::_1, placeholders::_2, x); //&使用bind生成的可调用对象做为自定义比较器
40
    priority_queue<int, vector<int>, decltype(cmp1)> my_que1(cmp1);//%注意，类型使用decltype自动推导，并且需要在优先队列构造函数内传入该比较器对象。
41

42
    priority_queue<int, vector<int>, decltype(bind(mycomp(), placeholders::_1, placeholders::_2, x))> my_que2(bind(mycomp(), placeholders::_1, placeholders::_2, x)); //直接写入。会非常长。
43

44

45
    //------测试部分---------
46
    for(int i = 0; i < vec.size(); i++){
47
        my_que1.push(vec[i]);
48
        my_que.push(vec[i]);
49
        my_que2.push(vec[i]);
50
    }
51

52
    cout <<"myque" << endl;
53
    while(!my_que.empty()){
54
        cout << my_que.top() << endl;
55
        my_que.pop();
56
    }
57

58
    cout << "myque1" << endl;
59
    while(!my_que1.empty()){
60
        cout << my_que1.top() << endl;
61
        my_que1.pop();
62
    }
63

64
    cout << "myque2" << endl;
65
    while(!my_que2.empty()){
66
        cout << my_que2.top() << endl;
67
        my_que2.pop();
68
    }
69
}
70
int main(){
71
    vector<int>a {1,2,3,9,100,7,5};
72
    func(a, 2);
73
    cout <<"vec" << endl;
74
    for(auto& i:a){
75
        cout <<i << endl;
76
    }
77
    return 0;
78
}

1
class mycomp{ //&priority_queue 的比较器
2
    public:
3
        bool operator()(int a, int b){
4
            if(abs(a-5) >= abs(b-5)){
5
                return false;
6
            }
7
            return true;
8
        }
9
};
10

11
int main(){
12
    priority_queue<int,vector<int>, mycomp>my_que{mycomp()}; //传入匿名对象使用花括号。
13
    my_que.push(10);
14

15

16
    return 0;
17
}