是否可以将std :: sort与带有额外参数的sort函数一起使用？

Question

This is something that I've been considering for a while. I've done some research and can't find anything on it, but I haven't found anything to the contrary either.

Consider the std::sort function in <algorithm> . It takes two iterators and a function pointer as arguments. So if I wanted to sort a vector of strings alphabetically, I would do something like this:

bool ascending(std::string lhs, std::string rhs) { return lhs < rhs; }

std::sort(my_vector.begin(), my_vector.end(), ascending);

The thing is that this type of sort function is case-sensitive, so would place a string beginning with lowercase 'a' after strings beginning with uppercase 'Z'. The only visible solution I see to this is creating an additional function along the lines of bool ascending_case_insensitive() . However, it would be nice if I could have a function bool ascending() with an additional bool is_case_sensitive parameter to use in sort. Is this possible?

Answer 1

Where you now have

bool ascending(std::string lhs, std::string rhs);

std::sort(my_vector.begin(), my_vector.end(), ascending);

you can have

bool ascending(std::string lhs, std::string rhs, bool case_sensitive);

using namespace std::placeholders;
std::sort(my_vector.begin(), my_vector.end(), std::bind(ascending, _1, _2, false));

The point of std::bind is to return an object that when invoked, calls the bound function, optionally with altered arguments. You can use it to change argument order, add optional parameters, or set parameters to specific fixed values.

Answer 2

Since std::sort takes an instance of the comparison functor, you can use arguments to your functor's constructor determine its behaviour. For example,

class StringCompare
{
public:
StringCompare(bool is_case_sensitive=true) : is_case_sensitive(is_case_sensitive){}
bool operator()(const string&, const string&);///This would handle the comparison using the is_case_sensitive flag
private:
bool is_case_sensitive;
};

std::sort(my_vector.begin(), my_vector.end(), StringCompare(true));//case-sensitive comparison
std::sort(my_vector.begin(), my_vector.end(), StringCompare(false));//case-insensitive comparison

Answer 3

There follows an example that includes a function call with a bound extra parameter and a lambda expression that captures the extra parameter by value:

#include <iostream>// for std::cout
#include <vector>// for std::vector
#include <functional> // for std::bind
#include <algorithm> // for std::sort

bool ltMod(int i, int j, int iMod) {
    return (i % iMod) < (j % iMod); 
}

int main() {
    std::vector<int> v = {3,2,5,1,4};
    int iMod = 4;

    std::cout << "\nExample for the usage of std::bind: ";
    // _1 and _2 stand for the two arguments of the relation iMod is the bound parameter
    std::sort(v.begin(),v.end(),std::bind(ltMod,std::placeholders::_1,std::placeholders::_2,iMod));

    for( auto i : v )   std::cout << i << ',';

    iMod = 3;

    std::cout << "\nExample for lambda: ";
    // lambdas are unnamed inplace functions
    // iMod is captured by value. You can use the value within the function.
    std::sort(v.begin(),v.end(),[iMod](int i, int j){ return ltMod(i,j,iMod); });
    for( auto i : v )   std::cout << i << ',';

    return 0;
}
/**
     Local Variables:
     compile-command: "g++ -std=c++11 test.cc -o a.exe"
     End:
*/

Answer 4

Thought that I would answer my own question in order to summarize the responses I've gotten. So from what I gather, I basically have two options.

The first would be to write a lambda function to handle my one-time case.

// Lambda solution.
std::sort(my_vector.begin(), my_vector.end(),
    [](std::string const &lhs, std::string const &rhs)    // Thanks for optimizing my example code guys. No, seriously. ;)
    {
        return boost::toupper(lhs) < boost::toupper(rhs);
    });

The second, more reusable option would be to create a functor to handle sort situations like these.

// Functor solution.
class SortAscending
{
private:
    bool _is_case_sensitive;
public:
    SortAscending(bool is_case_sensitive) :
        _is_case_sensitive(is_case_sensitive);

    bool operator()(std::string const &lhs, std::string const &rhs)
    {
        if (_is_case_sensitive)
            return boost::toupper(lhs) < boost::toupper(rhs);
        else
            return lhs < rhs;
    }
};

std::sort(my_vector.begin(), my_vector.end(), SortAscending(false));

So think that pretty much sums up my options?