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
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
| // g++ -Wall -Wextra -Wconversion -Wsign-conversion -Ofast -std=c++14 -pedantic -fopenmp main.cpp -o main && ./main
#include <iostream>
#include <array>
#include <string>
#include <vector>
#include <algorithm>
#include <tuple>
template<int ...>
struct seq { };
template<int N, int ...S>
struct gens : gens<N-1, N-1, S...> { };
template<int ...S>
struct gens<0, S...> {
typedef seq<S...> type;
};
struct employee
{
int f_id;
std::string f_firstname;
std::string f_lastname;
int f_ssnumber;
employee(int id, std::string const & firstname, std::string const & lastname, int ssnumber) :
f_id(id), f_firstname(firstname), f_lastname(lastname), f_ssnumber(ssnumber)
{ }
};
std::ostream & operator <<(std::ostream & out, employee const & e)
{
out << "{ " << e.f_id << ", " << e.f_firstname << ", " << e.f_lastname << ", " << e.f_ssnumber << " }";
return out;
}
template <class T, class ... getter_t>
struct comp_generic
{
private:
std::tuple<getter_t const ...> m_getters;
public:
comp_generic(getter_t const & ... getters) : m_getters(std::make_tuple(getters...))
{ }
// operator()(T const & a, T const & b)
bool operator()(T const & a, T const & b)
{
return fct_T_T(a, b, typename gens<sizeof...(getter_t)>::type());
}
template <int ... S>
bool fct_T_T(T const & a, T const & b, seq<S ...> const)
{
return std::tie(std::get<S>(m_getters)(a)...) < std::tie(std::get<S>(m_getters)(b)...);
}
// operator()(T const & t, values_t const & values)
template <class values_t>
bool operator()(T const & t, values_t const & values)
{
return fct_T_values(t, values, typename gens<sizeof...(getter_t)>::type());
}
template <class values_t, int ... S>
bool fct_T_values(T const & t, values_t const & values, seq<S ...> const)
{
return std::tie(std::get<S>(m_getters)(t)...) < values;
}
// operator()(values_t const & values, T const & t)
template <class values_t>
bool operator()(values_t const & values, T const & t)
{
return fct_values_T(values, t, typename gens<sizeof...(getter_t)>::type());
}
template <class values_t, int ... S>
bool fct_values_T(values_t const & values, T const & t, seq<S ...> const)
{
return values < std::tie(std::get<S>(m_getters)(t)...);
}
};
template <class T, class ... getter_t>
auto make_comp(getter_t const & ... getters)
{
return comp_generic<T, getter_t const & ...>(getters...);
}
int main()
{
std::vector<employee> v;
v.push_back(employee(5, "John", "Smithh", 1582));
v.push_back(employee(3, "Paul", "Howard", 1777));
v.push_back(employee(1, "Paul", "Howard", 1798));
v.push_back(employee(4, "Jane", "Howard", 1847));
v.push_back(employee(7, "Jude", "Muller", 1325));
for (auto const & e : v) { std::cout << e << std::endl; } std::cout << std::endl;
auto const get_id = [](employee const & e) -> int const & { return e.f_id; };
auto const get_firstname = [](employee const & e) -> std::string const & { return e.f_firstname; };
auto const get_lastname = [](employee const & e) -> std::string const & { return e.f_lastname; };
auto const get_ssnumber = [](employee const & e) -> int const & { return e.f_ssnumber; };
auto const comp_ssnumber = make_comp<employee>(get_ssnumber);
auto const comp_firstname = make_comp<employee>(get_firstname);
auto const comp_id = make_comp<employee>(get_id);
auto const comp_lastname_firstname = make_comp<employee>(get_lastname, get_firstname);
auto const comp_lastname_firstname_id = make_comp<employee>(get_lastname, get_firstname, get_id);
std::cout << "Sort by id" << std::endl;
std::sort(v.begin(), v.end(), comp_id);
if (std::binary_search(v.begin(), v.end(), std::make_tuple(5), comp_id))
{
std::cout << "{ 5, _, _, _ } found in:" << std::endl;
}
for (auto const & e : v) { std::cout << e << std::endl; } std::cout << std::endl;
std::cout << "Sort by firstname" << std::endl;
std::sort(v.begin(), v.end(), comp_firstname);
for (auto const & e : v) { std::cout << e << std::endl; } std::cout << std::endl;
std::cout << "Sort by lastname and firstname" << std::endl;
std::sort(v.begin(), v.end(), comp_lastname_firstname);
for (auto const & e : v) { std::cout << e << std::endl; } std::cout << std::endl;
std::cout << "Sort by ssnumber" << std::endl;
std::sort(v.begin(), v.end(), comp_ssnumber);
for (auto const & e : v) { std::cout << e << std::endl; } std::cout << std::endl;
std::cout << "Sort by lastname and firstname and id" << std::endl;
std::sort(v.begin(), v.end(), comp_lastname_firstname_id);
if (std::binary_search(v.begin(), v.end(), std::make_tuple("Howard", "Jane", 4), comp_lastname_firstname_id))
{
std::cout << "{ 4, Howard, Jane, _ }" << "found:" << std::endl;
}
for (auto const & e : v) { std::cout << e << std::endl; } std::cout << std::endl;
return 0;
} |
Étendre un foncteur générique simple
)
Répondre avec citation
comme souvent en C++ 
Envoyé par camboui
Partager