Sort std :: list case sensitive elements

Question

#include <list>
#include <string>
using std::string;
using std::list;

int main()
{
    list <string> list_;
    list_.push_back("C");
    list_.push_back("a");
    list_.push_back("b");

    list_.sort();
}

Does the sort () function sort the elements according to their character codes? I want the result to be a b Cafter sorting.

Answer 1

The default comparator ( <) using default char_traits< char >sorts your list as C a b.

See list :: sort .

To achieve the desired order, a b Cyou can:

• make your type list stringwith customchar_traits or

• provide an instance of a custom string mapper for sorte.g.

  bool istring_less(const string& lhs, const string& rhs) {
    string::const_iterator \
      lb = lhs.begin(), le = lhs.end(),
      rb = rhs.begin(), re = rhs.end();
    const char lc, rc;
    for ( ; lb != le && rb != re; ++lb, ++rb) {
      lc = tolower(*lb);
      rc = tolower(*rb);
      if (*lc < *rc) return true;
      if (*lc > *rc) return false;
    }
    // if rhs is longer than lhs then lhs<rhs
    return (rb != re);
  }
  ...
  list.sort(istring_less);
  

Answer 2

, . :

struct char_iless 
: public std::binary_function<char, char, bool>
{
    std::locale loc;

    char_iless(std::locale const & loc=std::locale()) : loc(loc) 
    {
    }

    bool operator()(char a, char b) const
    {
        return std::tolower(a, loc) < std::tolower(b, loc);
    }
};

:

char_iless('a', 'b', my_locale);

std::locale() my_locale, , .

Boost, String Algorithms am is_iless, .

std::lexicographical_compare:

struct str_iless 
: public std::binary_function<std::string, std::string, bool>
{
    std::locale loc;

    str_iless(std::locale const & loc=std::locale()) : loc(loc) 
    {
    }

    bool operator()(std::string const & a, std::string const & b) const
    {
        return std::lexicographical_compare(
            a.begin(), a.end(),
            b.begin(), b.end(),  
            char_iless(loc)
        );
    }
};

, :

int main()
{
    std::list<std::string> list;
    list.push_back("C");
    list.push_back("a");
    list.push_back("b");

    // Sort using default locale
    list.sort(str_iless());  

    // Sort using French locale 
    // (warning: this locale format string is MS specific)
    std::locale loc("French_France.1252");
    list.sort(str_iless(loc));
}

Answer 3

:

#include    <string>
#include    <cstring>
#include    <iostream>
#include    <boost/algorithm/string.hpp>

using std::string;
using std::list;
using std::cout;
using std::endl;

using namespace boost::algorithm;

// recommended in Meyers, Effective STL when internationalization and embedded
// NULLs aren't an issue.  Much faster than the STL or Boost lex versions.
struct ciLessLibC : public std::binary_function<string, string, bool> {
    bool operator()(const string &lhs, const string &rhs) const {
        return strcasecmp(lhs.c_str(), rhs.c_str()) < 0 ? 1 : 0;
    }
};

// If you need sorting according to the default system local
struct ciLessBoost : std::binary_function<std::string, std::string, bool>
{
    bool operator() (const std::string & s1, const std::string & s2) const {
        return lexicographical_compare(s1, s2, is_iless());
    }
};

int main(void) {
    list <string> list_;
    list_.push_back("C");
    list_.push_back("a");
    list_.push_back("b");

    list_.sort(ciLessLibC());
    list_.sort(ciLessBoost());

    return 0;
}

Answer 4

,