I am trying to print a Russian "ф" (U+0444 CYRILLIC SMALL LETTER EF) character, which is given a code of decimal 1092. Using C++, how can I print out this character? I would have thought something along the lines of the following would work, yet...
int main (){
wchar_t f = '1060';
cout << f << endl;
}
To represent the character you can use Universal Character Names (UCNs). The character 'ф' has the Unicode value U+0444 and so in C++ you could write it '\u0444' or '\U00000444'. Also if the source code encoding supports this character then you can just write it literally in your source code.
// both of these assume that the character can be represented with
// a single char in the execution encoding
char b = '\u0444';
char a = 'ф'; // this line additionally assumes that the source character encoding supports this character
Printing such characters out depends on what you're printing to. If you're printing to a Unix terminal emulator, the terminal emulator is using an encoding that supports this character, and that encoding matches the compiler's execution encoding, then you can do the following:
#include <iostream>
int main() {
std::cout << "Hello, ф or \u0444!\n";
}
This program does not require that 'ф' can be represented in a single char. On OS X and most any modern Linux install this will work just fine, because the source, execution, and console encodings will all be UTF-8 (which supports all Unicode characters).
Things are harder with Windows and there are different possibilities with different tradeoffs.
Probably the best, if you don't need portable code (you'll be using wchar_t, which should really be avoided on every other platform), is to set the mode of the output file handle to take only UTF-16 data.
#include <iostream>
#include <io.h>
#include <fcntl.h>
int main() {
_setmode(_fileno(stdout), _O_U16TEXT);
std::wcout << L"Hello, \u0444!\n";
}
Portable code is more difficult.
char if the execution charset is, for example, ISO-8859-5. Specifically it will be the byte 0xE4. Note that I'm not suggesting that using such an execution charset is a good practice, I'm simply describing how C++ works. –
Zymogenic \u is different from using \x. –
Zymogenic When compiling with -std=c++11, one can simply
const char *s = u8"\u0444";
cout << s << endl;
\uXXXX and \UXXXXXXXX are called universal-character-name. A string literal of the form u8"..." is UTF-8 string literal. Both are specified in the standard. –
Liederkranz Ultimately, this is completely platform-dependent. Unicode-support is, unfortunately, very poor in Standard C++. For GCC, you will have to make it a narrow string, as they use UTF-8, and Windows wants a wide string, and you must output to wcout.
// GCC
std::cout << "ф";
// Windoze
wcout << L"ф";
\uXXXX where the XXXX is for hex digits. Unfortunately, this leaves all the characters past U+FFFF out. –
Holeproof wchar_t x = '\u0400'; for instance, does not work –
Realgar \u, at least on windows. –
Erle \UXXXXXXXX. –
Zymogenic std::wcout is also an option outside of Windows. –
Spinster '\u0400' is a narrow-character literal. You seem to assume that \u0400 exists in the execution character set. According to N3242 [lex.ccon]/5: "A universal-character-name is translated to the encoding, in the appropriate execution character set, of the character named. If there is no such encoding, the universal-character-name is translated to an implementation defined encoding." –
Acacia This code works in Linux (C++11, Geany, and GCC 7.4 (g++. 2018-12-06)):
#include <iostream>
using namespace std;
int utf8_to_unicode(string utf8_code);
string unicode_to_utf8(int unicode);
int main()
{
cout << unicode_to_utf8(36) << '\t';
cout << unicode_to_utf8(162) << '\t';
cout << unicode_to_utf8(8364) << '\t';
cout << unicode_to_utf8(128578) << endl;
cout << unicode_to_utf8(0x24) << '\t';
cout << unicode_to_utf8(0xa2) << '\t';
cout << unicode_to_utf8(0x20ac) << '\t';
cout << unicode_to_utf8(0x1f642) << endl;
cout << utf8_to_unicode("$") << '\t';
cout << utf8_to_unicode("¢") << '\t';
cout << utf8_to_unicode("€") << '\t';
cout << utf8_to_unicode("🙂") << endl;
cout << utf8_to_unicode("\x24") << '\t';
cout << utf8_to_unicode("\xc2\xa2") << '\t';
cout << utf8_to_unicode("\xe2\x82\xac") << '\t';
cout << utf8_to_unicode("\xf0\x9f\x99\x82") << endl;
return 0;
}
int utf8_to_unicode(string utf8_code)
{
unsigned utf8_size = utf8_code.length();
int unicode = 0;
for (unsigned p=0; p<utf8_size; ++p)
{
int bit_count = (p? 6: 8 - utf8_size - (utf8_size == 1? 0: 1)),
shift = (p < utf8_size - 1? (6*(utf8_size - p - 1)): 0);
for (int k=0; k<bit_count; ++k)
unicode += ((utf8_code[p] & (1 << k)) << shift);
}
return unicode;
}
string unicode_to_utf8(int unicode)
{
string s;
if (unicode>=0 and unicode <= 0x7f) // 7F(16) = 127(10)
{
s = static_cast<char>(unicode);
return s;
}
else if (unicode <= 0x7ff) // 7FF(16) = 2047(10)
{
unsigned char c1 = 192, c2 = 128;
for (int k=0; k<11; ++k)
{
if (k < 6)
c2 |= (unicode % 64) & (1 << k);
else
c1 |= (unicode >> 6) & (1 << (k - 6));
}
s = c1;
s += c2;
return s;
}
else if (unicode <= 0xffff) // FFFF(16) = 65535(10)
{
unsigned char c1 = 224, c2 = 128, c3 = 128;
for (int k=0; k<16; ++k)
{
if (k < 6)
c3 |= (unicode % 64) & (1 << k);
else if
(k < 12) c2 |= (unicode >> 6) & (1 << (k - 6));
else
c1 |= (unicode >> 12) & (1 << (k - 12));
}
s = c1;
s += c2;
s += c3;
return s;
}
else if (unicode <= 0x1fffff) // 1FFFFF(16) = 2097151(10)
{
unsigned char c1 = 240, c2 = 128, c3 = 128, c4 = 128;
for (int k=0; k<21; ++k)
{
if (k < 6)
c4 |= (unicode % 64) & (1 << k);
else if (k < 12)
c3 |= (unicode >> 6) & (1 << (k - 6));
else if (k < 18)
c2 |= (unicode >> 12) & (1 << (k - 12));
else
c1 |= (unicode >> 18) & (1 << (k - 18));
}
s = c1;
s += c2;
s += c3;
s += c4;
return s;
}
else if (unicode <= 0x3ffffff) // 3FFFFFF(16) = 67108863(10)
{
; // Actually, there are no 5-bytes unicodes
}
else if (unicode <= 0x7fffffff) // 7FFFFFFF(16) = 2147483647(10)
{
; // Actually, there are no 6-bytes unicodes
}
else
; // Incorrect unicode (< 0 or > 2147483647)
return "";
}
More:
If you use Windows (note, we are using printf(), not cout):
// Save as UTF-8 without a signature
#include <stdio.h>
#include<windows.h>
int main (){
SetConsoleOutputCP(65001);
printf("ф\n");
}
It is not Unicode, but it is working—Windows-1251 instead of UTF-8:
// Save as Windows 1251
#include <iostream>
#include<windows.h>
using namespace std;
int main (){
SetConsoleOutputCP(1251);
cout << "ф" << endl;
}
In C++23 you'll be able to do it with std::print which supports Unicode:
#include <print>
int main () {
std::print("{}\n", "ф");
}
Until std::print is widely available you can use the open-source {fmt} library, it is based on (godbolt):
#include <fmt/core.h>
int main () {
fmt::print("{}\n", "ф");
}
Just make sure that your literal encoding is UTF-8 which is normally the default on most platforms and on Windows/MSVC is enabled with /utf-8.
I wouldn't recommend using wchar_t because it requires nonportable APIs such as _setmode.
Disclaimer: I'm the author of {fmt} and C++23 std::print.
'1060' is four characters, and won't compile under the standard. You should just treat the character as a number, if your wide characters match 1:1 with Unicode (check your locale settings).
int main (){
wchar_t f = 1060;
wcout << f << endl;
}
operator << and Do The Right Thing. Not so much, I guess? –
Holeproof '1060' is a multi-char character literal of type int, and is entirely legal under standard C++. It's value is implementation defined though. Most implementations will take the values of the characters and concatenate them to produce a single integral value. These are sometimes used for so-called 'FourCC's. –
Zymogenic I needed to show the string in the UI as well as save that to an XML configuration file. The above specified format is good for string in c++, I would add we can have the xml compatible string for the special character by replacing "\u" by "&#x" and adding a ";" at the end.
For example:
C++: "\u0444" → XML : "ф"
In Linux, I can just do:
std::cout << "ф";
I just copy-pasted characters from here and it didn't fail for at least the random sample that I tried on.
Another solution in Linux:
string a = "Ф";
cout << "Ф = \xd0\xa4 = " << hex
<< int(static_cast<unsigned char>(a[0]))
<< int(static_cast<unsigned char>(a[1])) << " (" << a.length() << "B)" << endl;
string b = "√";
cout << "√ = \xe2\x88\x9a = " << hex
<< int(static_cast<unsigned char>(b[0]))
<< int(static_cast<unsigned char>(b[1]))
<< int(static_cast<unsigned char>(b[2])) << " (" << b.length() << "B)" << endl;
Special thanks to the answer here for more-or-less the same question.
For me, all I needed was setlocale(LC_ALL, "en_US.UTF-8");
Then, I could use even raw wchar_t characters.
© 2022 - 2024 — McMap. All rights reserved.
std::cout. (And even when those two steps are done correctly it's a different matter altogether of correctly displaying the character inside whateverstd::coutis connected to.) – Spinster