当char包含表情符号时如何比较char？

Question

General Overview:

I have a list of names, each name is a string& . A common action one wants to do with a list of strings is sort the strings in alphabetical order.

One way to do this is to convert both strings to the same case, start with the first character in each string, and evaluate the characters to see which comes first in the alphabet along the lines of if (char1 > char2) , repeating until the two characters being compared are not equal or until reaching the last character in the shorter string.

Emoji characters always evaluate to ... interesting ... char values, which, when using a sorting algorithm like one described above, emoji char's are always sorted to come before alphanumeric characters.

Goal: Sorting emoji strings, or strings that merely start with an emoji, before or after the purely alphanumeric strings is arbitrary. I'd like to be able to control where in alphabetical order emoji characters/strings are sorted: the choice of after 'Z'/'z' or before 'A'/'a'.

(I'm not saying I'd like to control where they are sorted to the point of placing them between other arbitrary characters like 'p' and 'q', and I'm not saying my goal is to control how emoji's are ordered when compared to other emojis, just to be clear.)

Some code to demonstrate:

bool compareStringsIgnoreCase(std::string& str1, std::string& str2)
{
   int i = 0;
   while (i < str1.length() && i < str2.length())
   {
      char firstChar = tolower(first[i]);
      char secondChar = tolower(second[i]);

      int firstCharAsInt = firstChar;
      int secondCharAsInt = secondChar;

      if (firstCharAsInt < secondCharAsInt)
           return true;
      else if (firstCharAsInt > secondCharAsInt)
           return false;
      i++;
   }
   return (str1.length() < str2.length());
}

If using str1 = "Abc" and str2 = 👍 , then when i = 0 , the other values are as follows: firstChar = 'a'

secondChar = '\\xf0'

firstCharAsInt = 97

secondCharAsInt = -16

With these values, it makes sense that firstCharAsInt > secondCharAsInt , and so the function returns true , and the emoji string is sorted to be before the "Abc" string. Again, what I'd like to be able to do is have emojis sorted after alphanumeric characters--the question is, how?

I tried out a handful of emojis, and their "char as int" values are always negative. Are emojis unique from other char 's in this way? If so that could be a simple and easy check that can identify them to place them after other char's. Open to other approaches as well.

Thanks

Answer 1

Emojis are Unicode characters, so on the assumption that your strings are encoded as UTF-8 then the easiest way to compare them is to convert them to a std::wstring . You can do this using std::codecvt . Although this is deprecated in C++17 there is no current convenient replacement.

So, one can do:

#include <string>
#include <codecvt>
#include <locale>
#include <cctype>

std::wstring widen (const std::string &s)
{
    std::wstring_convert <std::codecvt_utf8 <wchar_t>, wchar_t> convert;
    return convert.from_bytes (s);
}

void lower_case_string (std::wstring &ws)
{
    for (auto &ch : ws)
        ch = tolower (ch);
}

// Return true if s1 == s2 (UTF-8, case insensitive)
bool compare (const std::string &s1, const std::string &s2)
{
    std::wstring ws1 = widen (s1);
    lower_case_string (ws1);
    std::wstring ws2 = widen (s2);
    lower_case_string (ws2);
    return ws1 == ws2;
}

Although please note that the comparison function one would use for sorting would be s1 < s2 .

Live demo

Answer 2

To answer my proposed approach: emoji's are not unique in that their "char as int" values are negative.

Other symbols, like '§' for instance, also evaluate to negative, in this case -62, and so are sorted before alphanumeric characters.

Checking for these negative values and targeting them to affect their sort order will work to change the sort order of emojis , but it will change the sort order of other extraneous characters as well which makes this approach an imperfect solution to the original goal.

A simple & clean way to do this would be to cast the "char as int" values to unsigned ints . The negative values would, after two's complement, be casted to high positive values and thus sort after the other positive values.