String Conversions and std::locale

// <charconv> — C++17
std::from_chars_result from_chars(const char* first, const char* last,
                                   T& value, int base = 10);
std::from_chars_result from_chars(const char* first, const char* last,
                                   FloatT& value,
                                   std::chars_format fmt = std::chars_format::general);
struct from_chars_result { const char* ptr; std::errc ec; };

std::to_chars_result to_chars(char* first, char* last, T value, int base = 10);
std::to_chars_result to_chars(char* first, char* last, FloatT value,
                               std::chars_format fmt);
std::to_chars_result to_chars(char* first, char* last, FloatT value,
                               std::chars_format fmt, int precision);
struct to_chars_result { char* ptr; std::errc ec; };

// <string> — C++11
int         stoi (const std::string& str, std::size_t* pos = nullptr, int base = 10);
long        stol (const std::string& str, std::size_t* pos = nullptr, int base = 10);
long long   stoll(const std::string& str, std::size_t* pos = nullptr, int base = 10);
float       stof (const std::string& str, std::size_t* pos = nullptr);
double      stod (const std::string& str, std::size_t* pos = nullptr);
std::string to_string(/* integral or floating-point */ val);

#include <charconv>
#include <string_view>

// Integer parsing — all implementations since C++17
std::string_view sv = "12345";
int n;
auto [ptr, ec] = std::from_chars(sv.data(), sv.data() + sv.size(), n);
if (ec == std::errc{}) {
    // success; ptr points one past the last consumed character
} else if (ec == std::errc::invalid_argument) {
    // no valid digits at start of input
} else if (ec == std::errc::result_out_of_range) {
    // value overflows int
}

// Detect partial consumption (useful when full input is required)
if (ptr != sv.data() + sv.size()) { /* trailing garbage */ }

// Alternative bases
int hex_val, bin_val;
std::from_chars("ff",   "ff"   + 2, hex_val, 16); // 255
std::from_chars("1010", "1010" + 4, bin_val, 2);  // 10

// Floating-point — C++17 standard, but implementation lagged:
// MSVC 2019 16.4+, GCC 11+, Clang 14+. Gate with __cpp_lib_to_chars if needed.
double d;
std::from_chars("3.14159", "3.14159" + 7, d);
// Produces the exact double nearest 3.14159 with round-trip guarantee

// Specific formats via std::chars_format
std::from_chars("3.14e2",  "3.14e2"  + 6, d, std::chars_format::scientific); // 314.0
std::from_chars("1.8p+1",  "1.8p+1"  + 6, d, std::chars_format::hex);        // 3.0

// from_chars does NOT skip leading whitespace — unlike strtol/sscanf
// " 42" → ec == errc::invalid_argument

#include <charconv>
#include <string_view>

char buf[32];

// Integer
auto [end, ec] = std::to_chars(buf, buf + sizeof(buf), 12345);
std::string_view result{buf, end};  // "12345"

// Hex — lowercase by specification
std::to_chars(buf, buf + sizeof(buf), 255, 16); // "ff"

// Float: shortest decimal that round-trips back to the exact same double
std::to_chars(buf, buf + sizeof(buf), 3.14159265358979);

// Fixed precision
std::to_chars(buf, buf + sizeof(buf), 3.14159, std::chars_format::fixed, 2);      // "3.14"
std::to_chars(buf, buf + sizeof(buf), 3.14159, std::chars_format::scientific);    // "3.14159e+00"
std::to_chars(buf, buf + sizeof(buf), 3.14159, std::chars_format::hex);           // hex float

// Zero-allocation boundary wrapper
std::string num_to_str(double val) {
    char buf[32];
    auto [end, ec] = std::to_chars(buf, buf + sizeof(buf), val);
    return {buf, end};  // single allocation at the output boundary only
}

#include <string>
#include <stdexcept>

// Integer — recognizes only ASCII digits regardless of locale
int n        = std::stoi("42");
long l       = std::stol("-1234567890");
long long ll = std::stoll("9876543210");
unsigned long ul = std::stoul("4294967295");

// Alternative bases
int hex = std::stoi("ff",   nullptr, 16); // 255
int oct = std::stoi("77",   nullptr, 8);  // 63
int bin = std::stoi("1010", nullptr, 2);  // 10

// idx receives the count of characters consumed; use it to detect trailing garbage
std::size_t idx;
int val = std::stoi("42abc", &idx);  // val=42, idx=2
if (idx != str.size()) { /* partial parse */ }

// Float — stod/stof call strtod, which IS locale-sensitive for decimal point.
// In a German locale (decimal=','), stod("3.14") may throw or return wrong value.
// Use from_chars when locale-independence is required.
double d      = std::stod("3.14159");
float  f      = std::stof("3.14");
long double ld = std::stold("3.14159265358979323846");

// Both integer and float variants throw on failure
try {
    std::stoi("not_a_number");          // throws std::invalid_argument
    std::stoi("99999999999999999999");  // throws std::out_of_range
} catch (const std::invalid_argument&) { /* input did not start with a digit */ }
  catch (const std::out_of_range&)      { /* overflow */ }

#include <string>
#include <format>  // C++20

std::string si = std::to_string(42);    // "42"
std::string sf = std::to_string(3.14);  // "3.140000" — always 6 decimal places, like %f
std::string sb = std::to_string(true);  // "1", not "true"

std::wstring wsi = std::to_wstring(42); // L"42" — wstring variant, C++11

// For anything beyond default format, prefer std::format (C++20):
std::string fixed   = std::format("{:.2f}", 3.14159);   // "3.14"
std::string sci     = std::format("{:e}", 3.14159);     // "3.141590e+00"
std::string boolean = std::format("{}", true);           // "true", not "1"
// std::format also produces shortest round-trip float by default: std::format("{}", 3.14)

#include <locale>
#include <sstream>
#include <iomanip>

std::locale classic = std::locale::classic(); // "C" locale — always available
std::locale sys     = std::locale("");         // system locale from LC_ALL/LANG

// Named locales — platform-dependent availability; throws std::runtime_error if absent
std::locale us("en_US.UTF-8");
std::locale de("de_DE.UTF-8");

// Imbue a stream — affects number, money, and time formatting
std::ostringstream oss;
oss.imbue(us);
oss << std::fixed << std::setprecision(2) << 1234567.89;
// oss.str() == "1,234,567.89"

oss.str("");
oss.imbue(de);
oss << std::fixed << std::setprecision(2) << 1234567.89;
// oss.str() == "1.234.567,89"

// locale::global() sets the global C++ locale and syncs the C locale (setlocale).
// NOT thread-safe if other threads use locale-sensitive operations simultaneously.
std::locale::global(std::locale("en_US.UTF-8"));

#include <locale>
#include <string>

// Query formatting rules via facets without stream I/O
const auto& np = std::use_facet<std::numpunct<char>>(std::locale("en_US.UTF-8"));
char tsep    = np.thousands_sep();  // ','
char dsep    = np.decimal_point();  // '.'
std::string g = np.grouping();      // "\3" — each byte is a group SIZE, not an ASCII digit

// Locale-aware collation — sorts "ä" near "a", not after "z" in German
const auto& coll = std::use_facet<std::collate<char>>(std::locale("de_DE.UTF-8"));
auto lt_de = [&](std::string_view a, std::string_view b) {
    return coll.compare(a.data(), a.data() + a.size(),
                        b.data(), b.data() + b.size()) < 0;
};

// Locale-aware character classification — two-argument form from <locale>
std::locale loc("en_US.UTF-8");
bool alpha = std::isalpha('é', loc);  // true with UTF-8 locale; false with classic()
bool space = std::isspace('\t', loc); // true
bool digit = std::isdigit('5', loc);  // true

#include <cctype>

// Single-argument versions use the current C locale.
// CRITICAL: argument must be representable as unsigned char, or be EOF.
// Passing a negative plain char is undefined behavior on most platforms (signed char).

// WRONG — UB when char is signed and c > 127
char c = '\xE9';
std::isalpha(c);

// CORRECT — cast first
std::isalpha(static_cast<unsigned char>(c));

// Helper that encapsulates the cast
auto classify = [](char c, auto fn) {
    return fn(static_cast<unsigned char>(c));
};

classify('a', std::isalpha);   // true
classify('5', std::isdigit);   // true
classify('!', std::ispunct);   // true
classify(' ', std::isspace);   // true
classify('A', std::isupper);   // true
classify('f', std::isxdigit);  // true

// Case conversion — return int; cast back to char explicitly
char upper = static_cast<char>(std::toupper(static_cast<unsigned char>('a'))); // 'A'
char lower = static_cast<char>(std::tolower(static_cast<unsigned char>('Z'))); // 'z'

#include <string>
#include <stdexcept>  // C++11

// Full integer family
int               i  = std::stoi  ("42");
long              l  = std::stol  ("42");
long long         ll = std::stoll ("42");
unsigned long     ul = std::stoul ("42");
unsigned long long ull = std::stoull("42");

// Arbitrary base — prefix "0x" or "0" is recognised automatically when base==0
int auto_base = std::stoi("0xFF",  nullptr, 0);   // 255, hex detected
int oct_auto  = std::stoi("0755",  nullptr, 0);   // 493, octal detected
int hex_exp   = std::stoi("0xFF",  nullptr, 16);  // 255, base explicit

// Detect trailing non-digit characters via pos
std::size_t consumed;
int partial = std::stoi("42abc", &consumed);  // partial==42, consumed==2
// Always verify when full-string parse is required:
std::string input = "42abc";
if (consumed != input.size()) { /* trailing garbage */ }

// Float family — decimal point follows the current C locale
float       f  = std::stof ("3.14");
double      d  = std::stod ("3.14159265358979");
long double ld = std::stold("3.14159265358979323846L");

// Exception behaviour — both exception types derive from std::logic_error
try {
    std::stoi("not-a-number");          // throws std::invalid_argument
    std::stoi("9999999999999999999");   // throws std::out_of_range
} catch (const std::invalid_argument& e) { /* no conversion could be performed */ }
  catch (const std::out_of_range& e)      { /* representable range exceeded    */ }

#include <charconv>   // C++17
#include <system_error>
#include <string_view>

// Basic integer parse — returns from_chars_result {ptr, ec}
std::string_view sv = "  42";   // note leading space
int n = 0;
auto [ptr, ec] = std::from_chars(sv.data(), sv.data() + sv.size(), n);
// ec == std::errc::invalid_argument — from_chars does NOT skip whitespace

// Strip whitespace manually, then parse
sv.remove_prefix(sv.find_first_not_of(' '));
std::from_chars(sv.data(), sv.data() + sv.size(), n);  // ec == errc{}, n == 42

// Hexadecimal and binary integers
int hex_n, bin_n;
std::from_chars("0xff" + 2, "0xff" + 4, hex_n, 16);   // 255  (caller strips "0x")
std::from_chars("1010",     "1010"  + 4, bin_n, 2);    // 10

// Full-string consume check
std::string_view full = "1234";
int v;
auto res = std::from_chars(full.data(), full.data() + full.size(), v);
bool fully_consumed = (res.ec == std::errc{}) && (res.ptr == full.data() + full.size());

// Floating-point — C++17 standard; requires GCC 11+, Clang 14+, MSVC 2019 16.4+
// Feature-test macro: __cpp_lib_to_chars >= 201907L
double d;
std::from_chars("3.14159265358979", "3.14159265358979" + 16, d);
// Result is the unique double nearest the mathematical value — round-trip safe

// Format flags via std::chars_format
std::from_chars("3.14e2",  "3.14e2"  + 6, d, std::chars_format::scientific); // 314.0
std::from_chars("1.cp+2",  "1.cp+2"  + 6, d, std::chars_format::hex);        // hexfloat
std::from_chars("3.14",    "3.14"    + 4, d, std::chars_format::fixed);       // 3.14

// Typical parser wrapper with structured binding
bool parse_int(std::string_view s, int& out) {
    auto [ptr, ec] = std::from_chars(s.data(), s.data() + s.size(), out);
    return ec == std::errc{} && ptr == s.data() + s.size();
}

#include <charconv>   // C++17
#include <array>
#include <string>

// Integer to char buffer
char buf[32];
auto [end, ec] = std::to_chars(buf, buf + sizeof(buf), 42);
// On success: ec == errc{}, buf[0..end) == "42"
std::string_view sv{buf, end};   // zero-copy view into the buffer

// Hexadecimal (lowercase by specification)
std::to_chars(buf, buf + sizeof(buf), 255,  16);  // "ff"
std::to_chars(buf, buf + sizeof(buf), 255,  2);   // "11111111"

// Float — shortest decimal that round-trips back to the exact same double
std::to_chars(buf, buf + sizeof(buf), 0.1);                                          // "0.1"
std::to_chars(buf, buf + sizeof(buf), 3.14159265358979, std::chars_format::fixed, 4); // "3.1416"
std::to_chars(buf, buf + sizeof(buf), 1e100, std::chars_format::scientific);          // "1e+100"
std::to_chars(buf, buf + sizeof(buf), 3.14,  std::chars_format::hex);                 // hexfloat

// Buffer-size safety — check for overflow
std::array<char, 4> small;
auto [p, e] = std::to_chars(small.data(), small.data() + small.size(), 99999);
if (e == std::errc::value_too_large) { /* buffer too small; no partial output written */ }

// Zero-allocation string conversion helper
std::string int_to_string(int val) {
    char buf[12];  // enough for any 32-bit int including sign
    auto [end, ec] = std::to_chars(buf, buf + sizeof(buf), val);
    return std::string{buf, end};
}

// C++11 — deprecated in C++17, removed discussion in C++26
#include <locale>
#include <codecvt>
#include <string>

// Convert UTF-8 <-> UTF-32
std::wstring_convert<std::codecvt_utf8<char32_t>, char32_t> conv32;
std::u32string u32 = conv32.from_bytes("hello");   // UTF-8 → UTF-32
std::string    u8  = conv32.to_bytes(u32);         // UTF-32 → UTF-8

// Convert UTF-8 <-> UTF-16
std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> conv16;
std::u16string u16 = conv16.from_bytes("hello");   // UTF-8 → UTF-16
std::string    back = conv16.to_bytes(u16);        // UTF-16 → UTF-8

// PREFERRED C++20 alternative: use std::u8string + platform-specific transcoding
// or a library. The standard has no replacement yet.

// Minimal portable UTF-8 → UTF-32 codepoint iteration (no deprecated APIs)
// C++20 — manual decode, no library dependency
#include <string_view>
#include <cstdint>

uint32_t decode_utf8(std::string_view& sv) {
    unsigned char c = static_cast<unsigned char>(sv[0]);
    uint32_t cp;
    int bytes;
    if      (c < 0x80)  { cp = c;          bytes = 1; }
    else if (c < 0xE0)  { cp = c & 0x1F;   bytes = 2; }
    else if (c < 0xF0)  { cp = c & 0x0F;   bytes = 3; }
    else                { cp = c & 0x07;   bytes = 4; }
    for (int i = 1; i < bytes; ++i)
        cp = (cp << 6) | (static_cast<unsigned char>(sv[i]) & 0x3F);
    sv.remove_prefix(bytes);
    return cp;
}

#include <locale>
#include <sstream>   // C++11

// num_put: format an integer using locale rules into an ostreambuf_iterator
std::locale loc("en_US.UTF-8");
std::ostringstream oss;
oss.imbue(loc);

const auto& np = std::use_facet<std::num_put<char>>(loc);
np.put(std::ostreambuf_iterator<char>(oss), oss, ' ', static_cast<long>(1234567));
// oss.str() == "1,234,567"  — thousands separator inserted by facet

// num_get: parse a locale-formatted number from an istreambuf_iterator
std::istringstream iss("1,234,567");
iss.imbue(loc);
const auto& ng = std::use_facet<std::num_get<char>>(loc);
long result = 0;
std::ios_base::iostate err = std::ios_base::goodbit;
ng.get(std::istreambuf_iterator<char>(iss), {}, iss, err, result);
// result == 1234567 if locale correctly groups by thousands

// numpunct — query formatting characters without doing I/O
const auto& punct = std::use_facet<std::numpunct<char>>(loc);
punct.decimal_point();  // '.'
punct.thousands_sep();  // ','
punct.grouping();       // "\3" — raw byte 3, NOT the character '3'
punct.truename();       // "true"
punct.falsename();      // "false"

#include <string>   // C++20

// Type aliases emphasising encoding
using Utf8String  = std::u8string;   // char8_t elements, C++20
using Utf16String = std::u16string;  // char16_t elements
using Utf32String = std::u32string;  // char32_t elements

// Literals — encoding is compile-time enforced, C++20
Utf8String  u8  = u8"hello é";   // UTF-8 encoded
Utf16String u16 = u"hello é";    // UTF-16 encoded
Utf32String u32 = U"hello é";    // UTF-32 encoded

// std::string and std::u8string are NOT implicitly convertible in C++20
// std::string  s = u8"hello";  // error: cannot convert char8_t* to char*
// Explicit bit-cast workaround (zero-cost):
std::string as_bytes(std::u8string_view u8sv) {
    return {reinterpret_cast<const char*>(u8sv.data()), u8sv.size()};
}

// simdutf — high-performance, header-available transcoding (not stdlib)
// Shows the idiomatic pattern for production UTF conversion:
// #include <simdutf.h>

// size_t utf16_len = simdutf::utf16_length_from_utf8(u8data, u8len);
// std::u16string out(utf16_len, 0);
// simdutf::convert_utf8_to_utf16le(u8data, u8len,
//                                   reinterpret_cast<char16_t*>(out.data()));

// ICU pattern (common in i18n applications):
// UnicodeString ustr = UnicodeString::fromUTF8(StringPiece(utf8_data, len));
// std::string utf8_out;
// ustr.toUTF8String(utf8_out);