C++

Forum

  • Forum
  • Lounge
  • A proposal to introduce general function

 
A proposal to introduce general functions std::reverse and std::sort

vlad from moscow (6539)
In most cases standard algorithms std::reverse and std::sort (and corresponding member functions of containers std::forward_list and std::list) are called over a whole container.

So I am suggesting to introduce such general functions std::reverse and std::sort that will accept the reference to a container.

Here is a demonstrative code that illustrates the proposal.

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
 
#include <iostream>
#include <algorithm>
#include <iterator>
#include <functional>
#include <vector>
#include <forward_list>
#include <list>
 
 
namespace N1 // std
{
 
template <typename T>
void reverse( T &c )
{
 std::reverse( std::begin( c ), std::end( c ) );
}
 
template <typename T, typename Allocator>
void reverse( std::forward_list<T, Allocator> &f )
{
   f.reverse();
}
 
template <typename T, typename Allocator>
void reverse( std::list<T, Allocator> &l )
{
     l.reverse();
}
 
template <typename T>
void sort( T &c )
{
   std::sort( std::begin( c ), std::end( c ) );
}
 
template <typename T, typename Allocator>
void sort( std::forward_list<T, Allocator> &f )
{
   f.sort();
}
 
template <typename T, typename Allocator>
void sort( std::list<T, Allocator> &l )
{
   l.sort();
}
 
template <typename T, typename Compare>
void sort( T &c, Compare comp )
{
   std::sort( std::begin( c ), std::end( c ), comp );
}
 
template <typename T, typename Allocator, typename Compare>
void sort( std::forward_list<T, Allocator> &f, Compare comp )
{
   f.sort( comp );
}
 
template <typename T, typename Allocator, typename Compare>
void sort( std::list<T, Allocator> &l, Compare comp )
{
   l.sort( comp );
}
 
} // end of N1
 
 
int main()
{
   int a[3] = { 1, 2, 3 };
   std::forward_list<int> f( std::begin( a ), std::end( a ) );
   std::list<int> l( std::begin( a ), std::end( a ) );
   std::vector<int> v( std::begin( a ), std::end( a ) );
 
   std::cout << "a:\t";
   for ( int x : a ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << "f:\t";
   for ( int x : f ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << "l:\t";
   for ( int x : l ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << "v:\t";
   for ( int x : v ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << std::endl;
 
   N1::reverse( a );
   N1::reverse( f );
   N1::reverse( l );
   N1::reverse( v );
 
   std::cout << "a:\t";
   for ( int x : a ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << "f:\t";
   for ( int x : f ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << "l:\t";
   for ( int x : l ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << "v:\t";
   for ( int x : v ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << std::endl;
 
   N1::sort( a );
   N1::sort( f );
   N1::sort( l );
   N1::sort( v );
 
   std::cout << "a:\t";
   for ( int x : a ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << "f:\t";
   for ( int x : f ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << "l:\t";
   for ( int x : l ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << "v:\t";
   for ( int x : v ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << std::endl;
 
   N1::sort( a, std::greater<int>() );
   N1::sort( f, std::greater<int>() );
   N1::sort( l, std::greater<int>() );
   N1::sort( v, std::greater<int>() );
 
   std::cout << "a:\t";
   for ( int x : a ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << "f:\t";
   for ( int x : f ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << "l:\t";
   for ( int x : l ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << "v:\t";
   for ( int x : v ) std::cout << x << ' ';
   std::cout << std::endl;
   std::cout << std::endl;
}


Any comments?
Last edited on
Cubbi (4774)
boost has that already,
1
2
3
4
5
6
7
8
9
10
11
12
 
#include <string>
#include <iostream>
#include <boost/range/algorithm/sort.hpp>
#include <boost/range/algorithm/reverse.hpp>

int main()
{
    std::string s = "Simpsons did it!";
    boost::sort(s);
    boost::reverse(s);
    std::cout << s << '\n';
}
 
tssponmiiiddS!


(wouldn't work on list/forward_list, though -- boost::sort requires a random-accessible range.. but if you're serious about making a library proposal, work it into boost.range)
Last edited on
vlad from moscow (6539)
Maybe I am mistaken but though it looks similarly it seems that ideas, mine and of the boost, are different. I am going to have general functions std::reverse and std::sort for any class that does not have even iterators, The only requirement they must satisfy is the presence of member functions sort and reverse without parameters or with one parameter denoting a predicate for an overloaded sort member function.
For the demonstrative example I selected the approach used for std:;swap however it would be better to write these general functions based on conditions

std::is_member_function_pointer<decltype( &Container::reverse)>::value
std::is_member_function_pointer<decltype( &Container::sort)>::value
Cubbi (4774)
I am going to have general functions std::reverse and std::sort for any class that does not have even iterators, The only requirement they must satisfy is the presence of member functions sort and reverse


Reminds me of something Stroustrup was talking about when visiting us last year regarding the endless overloads of swap, begin, and end and his crazy plan on how to get rid of them all..

Anyway, if it's different from range, make a new boost library, but chances for it to become widely accepted are pretty low.
vlad from moscow (6539)
Well, the problem that would be resolved by introducing such functions is that without them it is impossible to write a generic code where for example a vector and/or a forward_list can be used.
What I need is to write some appropriate realizations of the functions based on the conditions I pointed out.
Topic archived. No new replies allowed.