string

// string standard header

#pragma once

#ifndef _STRING_

#define _STRING_

#ifndef RC_INVOKED #include <istream> #include <xstring_insert.h>

#if _HAS_CXX17

#include <xpolymorphic_allocator.h> #endif /* _HAS_CXX17 */

#pragma pack(push,_CRT_PACKING)

#pragma pack(push,

)

#pragma warning(push,_STL_WARNING_LEVEL)

#pragma warning(push,

)

#pragma warning(disable: _STL_DISABLED_WARNINGS)

#pragma warning(disable:

4455

4494

4619

4643

4702

4984

4988

)

_STL_DISABLE_CLANG_WARNINGS

#pragma push_macro("new")

#undef new

_STD_BEGIN

namespace

std

{

// basic_string INSERTERS AND EXTRACTORS

template

class

_Elem

class

_Traits

class

_Alloc

inline

basic_istream

_Elem

_Traits

operator

(

basic_istream

_Elem

_Traits

>&&

_Istr

basic_string

_Elem

_Traits

_Alloc

_Str

) {

// extract a string

typedef

ctype

_Elem

_Ctype

;

typedef

basic_istream

_Elem

_Traits

_Myis

;

typedef

basic_string

_Elem

_Traits

_Alloc

_Mystr

;

typedef

typename

_Mystr

size_type

_Mysizt

;

ios_base

iostate

_State

ios_base

goodbit

;

bool

_Changed

false

;

const

typename

_Myis

sentry

_Ok

(

_Istr

);

(

_Ok

) {

// state okay, extract characters

const _Ctype& _Ctype_fac = _STD use_facet<_Ctype>(_Istr.getloc());

const

_Ctype

_Ctype_fac

= ::

std

use_facet

_Ctype

_Istr

getloc

());

_Str

erase

();

_TRY_IO_BEGIN

try

{

_Mysizt

_Size

_Istr

width

() && (

_Mysizt

)

_Istr

width

() <

_Str

max_size

() ? (

_Mysizt

)

_Istr

width

() :

_Str

max_size

();

typename

_Traits

::int_type

_Meta

_Istr

rdbuf

()->sgetc();

for

(;

_Size

; --

_Size

_Meta

_Istr

rdbuf

()->snextc())

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

)) {

// end of file, quit

_State

ios_base

eofbit

;

break

; }

else

(

_Ctype_fac

(

_Ctype

space

_Traits

::to_char_type(

_Meta

)))

break

;

// whitespace, quit

else

{

// add character to string

_Str

push_back

(

_Traits

::to_char_type(

_Meta

));

_Changed

true

; }

_CATCH_IO_(_Istr)

}

catch

(...) { (

_Istr

setstate

(

ios_base

badbit

true

); }

}

_Istr

width

(

);

_Changed

)

_State

ios_base

failbit

;

_Istr

setstate

(

_State

);

return

(

_Istr

); }

template

class

_Elem

class

_Traits

class

_Alloc

inline

basic_istream

_Elem

_Traits

getline

(

basic_istream

_Elem

_Traits

>&&

_Istr

basic_string

_Elem

_Traits

_Alloc

_Str

const

_Elem

_Delim

) {

// get characters into string, discard delimiter

typedef

basic_istream

_Elem

_Traits

_Myis

;

ios_base

iostate

_State

ios_base

goodbit

;

bool

_Changed

false

;

const

typename

_Myis

sentry

_Ok

(

_Istr

true

);

(

_Ok

) {

// state okay, extract characters

_TRY_IO_BEGIN

try

{

_Str

erase

();

const

typename

_Traits

::int_type

_Metadelim

_Traits

::to_int_type(

_Delim

);

typename

_Traits

::int_type

_Meta

_Istr

rdbuf

()->sgetc();

for

(; ;

_Meta

_Istr

rdbuf

()->snextc())

(

_Traits

::eq_int_type(

_Traits

::eof(),

_Meta

)) {

// end of file, quit

_State

ios_base

eofbit

;

break

; }

else

(

_Traits

::eq_int_type(

_Meta

_Metadelim

)) {

// got a delimiter, discard it and quit

_Changed

true

;

_Istr

rdbuf

()->sbumpc();

break

; }

else

(

_Str

max_size

() <=

_Str

size

()) {

// string too large, quit

_State

ios_base

failbit

;

break

; }

else

{

// got a character, add it to string

_Str

_Traits

::to_char_type(

_Meta

);

_Changed

true

; }

_CATCH_IO_(_Istr)

}

catch

(...) { (

_Istr

setstate

(

ios_base

badbit

true

); }

}

_Changed

)

_State

ios_base

failbit

;

_Istr

setstate

(

_State

);

return

(

_Istr

); }

template

class

_Elem

class

_Traits

class

_Alloc

inline

basic_istream

_Elem

_Traits

getline

(

basic_istream

_Elem

_Traits

>&&

_Istr

basic_string

_Elem

_Traits

_Alloc

_Str

) {

// get characters into string, discard newline

return

(

getline

(

_Istr

_Str

_Istr

widen

(

'\n'

))); }

template

class

_Elem

class

_Traits

class

_Alloc

inline

basic_istream

_Elem

_Traits

operator

(

basic_istream

_Elem

_Traits

_Istr

basic_string

_Elem

_Traits

_Alloc

_Str

) {

// extract a string

return (_STD move(_Istr) >> _Str);

return

(::

std

move

(

_Istr

) >>

_Str

);

}

template

class

_Elem

class

_Traits

class

_Alloc

inline

basic_istream

_Elem

_Traits

getline

(

basic_istream

_Elem

_Traits

_Istr

basic_string

_Elem

_Traits

_Alloc

_Str

const

_Elem

_Delim

) {

// get characters into string, discard delimiter

return (getline(_STD move(_Istr), _Str, _Delim));

return

(

getline

(::

std

move

(

_Istr

_Str

_Delim

));

}

template

class

_Elem

class

_Traits

class

_Alloc

inline

basic_istream

_Elem

_Traits

getline

(

basic_istream

_Elem

_Traits

_Istr

basic_string

_Elem

_Traits

_Alloc

_Str

) {

// get characters into string, discard newline

return (getline(_STD move(_Istr), _Str, _Istr.widen('\n')));

return

(

getline

(::

std

move

(

_Istr

_Str

_Istr

widen

(

'\n'

)));

}

template

class

_Elem

class

_Traits

class

_Alloc

inline

basic_ostream

_Elem

_Traits

operator

(

basic_ostream

_Elem

_Traits

_Ostr

const

basic_string

_Elem

_Traits

_Alloc

_Str

) {

// insert a string

return

(

_Insert_string

(

_Ostr

_Str

data

(),

_Str

size

())); }

// sto* NARROW CONVERSIONS

inline

int

stoi

(

const

string

_Str

size_t

_Idx

nullptr

int

_Base

) {

// convert string to int

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

char

_Ptr

_Str

c_str

();

char

_Eptr

;

_Errno_ref

;

const long _Ans = _CSTD strtol(_Ptr, &_Eptr, _Base);

const

long

_Ans

= ::

strtol

(

_Ptr

, &

_Eptr

_Base

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stoi argument"

);

if (_Errno_ref == ERANGE || _Ans < INT_MIN || INT_MAX < _Ans)

(

_Errno_ref

_Ans

2147483647

) ||

2147483647

_Ans

)

_Xout_of_range

(

"stoi argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

((

int

)

_Ans

); }

inline

long

stol

(

const

string

_Str

size_t

_Idx

nullptr

int

_Base

) {

// convert string to long

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

char

_Ptr

_Str

c_str

();

char

_Eptr

;

_Errno_ref

;

const long _Ans = _CSTD strtol(_Ptr, &_Eptr, _Base);

const

long

_Ans

= ::

strtol

(

_Ptr

, &

_Eptr

_Base

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stol argument"

);

if (_Errno_ref == ERANGE)

(

_Errno_ref

)

_Xout_of_range

(

"stol argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

(

_Ans

); }

inline

unsigned

long

stoul

(

const

string

_Str

size_t

_Idx

nullptr

int

_Base

) {

// convert string to unsigned long

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

char

_Ptr

_Str

c_str

();

char

_Eptr

;

_Errno_ref

;

const unsigned long _Ans = _CSTD strtoul(_Ptr, &_Eptr, _Base);

const

unsigned

long

_Ans

= ::

strtoul

(

_Ptr

, &

_Eptr

_Base

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stoul argument"

);

if (_Errno_ref == ERANGE)

(

_Errno_ref

)

_Xout_of_range

(

"stoul argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

(

_Ans

); }

inline

long

stoll

(

const

string

_Str

size_t

_Idx

nullptr

int

_Base

) {

// convert string to long long

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

char

_Ptr

_Str

c_str

();

char

_Eptr

;

_Errno_ref

;

const long long _Ans = _CSTD strtoll(_Ptr, &_Eptr, _Base);

const

long

_Ans

= ::

strtoll

(

_Ptr

, &

_Eptr

_Base

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stoll argument"

);

if (_Errno_ref == ERANGE)

(

_Errno_ref

)

_Xout_of_range

(

"stoll argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

(

_Ans

); }

inline

unsigned

long

stoull

(

const

string

_Str

size_t

_Idx

nullptr

int

_Base

) {

// convert string to unsigned long long

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

char

_Ptr

_Str

c_str

();

char

_Eptr

;

_Errno_ref

;

const unsigned long long _Ans = _CSTD strtoull(_Ptr, &_Eptr, _Base);

const

unsigned

long

_Ans

= ::

strtoull

(

_Ptr

, &

_Eptr

_Base

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stoull argument"

);

if (_Errno_ref == ERANGE)

(

_Errno_ref

)

_Xout_of_range

(

"stoull argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

(

_Ans

); }

inline

float

stof

(

const

string

_Str

size_t

_Idx

nullptr

) {

// convert string to float

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

char

_Ptr

_Str

c_str

();

char

_Eptr

;

_Errno_ref

;

const float _Ans = _CSTD strtof(_Ptr, &_Eptr);

const

float

_Ans

= ::

strtof

(

_Ptr

, &

_Eptr

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stof argument"

);

if (_Errno_ref == ERANGE)

(

_Errno_ref

)

_Xout_of_range

(

"stof argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

(

_Ans

); }

inline

double

stod

(

const

string

_Str

size_t

_Idx

nullptr

) {

// convert string to double

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

char

_Ptr

_Str

c_str

();

char

_Eptr

;

_Errno_ref

;

const double _Ans = _CSTD strtod(_Ptr, &_Eptr);

const

double

_Ans

= ::

strtod

(

_Ptr

, &

_Eptr

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stod argument"

);

if (_Errno_ref == ERANGE)

(

_Errno_ref

)

_Xout_of_range

(

"stod argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

(

_Ans

); }

inline

long

double

stold

(

const

string

_Str

size_t

_Idx

nullptr

) {

// convert string to long double

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

char

_Ptr

_Str

c_str

();

char

_Eptr

;

_Errno_ref

;

const long double _Ans = _CSTD strtold(_Ptr, &_Eptr);

const

long

double

_Ans

= ::

strtold

(

_Ptr

, &

_Eptr

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stold argument"

);

if (_Errno_ref == ERANGE)

(

_Errno_ref

)

_Xout_of_range

(

"stold argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

(

_Ans

); }

// sto* WIDE CONVERSIONS

inline

int

stoi

(

const

wstring

_Str

size_t

_Idx

nullptr

int

_Base

) {

// convert wstring to int

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

wchar_t

_Ptr

_Str

c_str

();

wchar_t

_Eptr

;

_Errno_ref

;

const long _Ans = _CSTD wcstol(_Ptr, &_Eptr, _Base);

const

long

_Ans

= ::

wcstol

(

_Ptr

, &

_Eptr

_Base

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stoi argument"

);

if (_Errno_ref == ERANGE || _Ans < INT_MIN || INT_MAX < _Ans)

(

_Errno_ref

_Ans

2147483647

) ||

2147483647

_Ans

)

_Xout_of_range

(

"stoi argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

((

int

)

_Ans

); }

inline

long

stol

(

const

wstring

_Str

size_t

_Idx

nullptr

int

_Base

) {

// convert wstring to long

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

wchar_t

_Ptr

_Str

c_str

();

wchar_t

_Eptr

;

_Errno_ref

;

const long _Ans = _CSTD wcstol(_Ptr, &_Eptr, _Base);

const

long

_Ans

= ::

wcstol

(

_Ptr

, &

_Eptr

_Base

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stol argument"

);

if (_Errno_ref == ERANGE)

(

_Errno_ref

)

_Xout_of_range

(

"stol argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

(

_Ans

); }

inline

unsigned

long

stoul

(

const

wstring

_Str

size_t

_Idx

nullptr

int

_Base

) {

// convert wstring to unsigned long

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

wchar_t

_Ptr

_Str

c_str

();

wchar_t

_Eptr

;

_Errno_ref

;

const unsigned long _Ans = _CSTD wcstoul(_Ptr, &_Eptr, _Base);

const

unsigned

long

_Ans

= ::

wcstoul

(

_Ptr

, &

_Eptr

_Base

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stoul argument"

);

if (_Errno_ref == ERANGE)

(

_Errno_ref

)

_Xout_of_range

(

"stoul argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

(

_Ans

); }

inline

long

stoll

(

const

wstring

_Str

size_t

_Idx

nullptr

int

_Base

) {

// convert wstring to long long

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

wchar_t

_Ptr

_Str

c_str

();

wchar_t

_Eptr

;

_Errno_ref

;

const long long _Ans = _CSTD wcstoll(_Ptr, &_Eptr, _Base);

const

long

_Ans

= ::

wcstoll

(

_Ptr

, &

_Eptr

_Base

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stoll argument"

);

if (_Errno_ref == ERANGE)

(

_Errno_ref

)

_Xout_of_range

(

"stoll argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

(

_Ans

); }

inline

unsigned

long

stoull

(

const

wstring

_Str

size_t

_Idx

nullptr

int

_Base

) {

// convert wstring to unsigned long long

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

wchar_t

_Ptr

_Str

c_str

();

wchar_t

_Eptr

;

_Errno_ref

;

const unsigned long long _Ans = _CSTD wcstoull(_Ptr, &_Eptr, _Base);

const

unsigned

long

_Ans

= ::

wcstoull

(

_Ptr

, &

_Eptr

_Base

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stoull argument"

);

if (_Errno_ref == ERANGE)

(

_Errno_ref

)

_Xout_of_range

(

"stoull argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

(

_Ans

); }

inline

float

stof

(

const

wstring

_Str

size_t

_Idx

nullptr

) {

// convert wstring to float

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

wchar_t

_Ptr

_Str

c_str

();

wchar_t

_Eptr

;

_Errno_ref

;

const float _Ans = _CSTD wcstof(_Ptr, &_Eptr);

const

float

_Ans

= ::

wcstof

(

_Ptr

, &

_Eptr

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stof argument"

);

if (_Errno_ref == ERANGE)

(

_Errno_ref

)

_Xout_of_range

(

"stof argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

(

_Ans

); }

inline

double

stod

(

const

wstring

_Str

size_t

_Idx

nullptr

) {

// convert wstring to double

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

wchar_t

_Ptr

_Str

c_str

();

wchar_t

_Eptr

;

_Errno_ref

;

const double _Ans = _CSTD wcstod(_Ptr, &_Eptr);

const

double

_Ans

= ::

wcstod

(

_Ptr

, &

_Eptr

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stod argument"

);

if (_Errno_ref == ERANGE)

(

_Errno_ref

)

_Xout_of_range

(

"stod argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

(

_Ans

); }

inline

long

double

stold

(

const

wstring

_Str

size_t

_Idx

nullptr

) {

// convert wstring to long double

int& _Errno_ref = errno; // Nonzero cost, pay it once

int

_Errno_ref

= (*

_errno

());

// Nonzero cost, pay it once

const

wchar_t

_Ptr

_Str

c_str

();

wchar_t

_Eptr

;

_Errno_ref

;

const long double _Ans = _CSTD wcstold(_Ptr, &_Eptr);

const

long

double

_Ans

= ::

wcstold

(

_Ptr

, &

_Eptr

);

(

_Ptr

_Eptr

)

_Xinvalid_argument

(

"invalid stold argument"

);

if (_Errno_ref == ERANGE)

(

_Errno_ref

)

_Xout_of_range

(

"stold argument out of range"

);

(

_Idx

nullptr

) *

_Idx

= (

size_t

)(

_Eptr

_Ptr

);

return

(

_Ans

); }

// HELPERS FOR to_string AND to_wstring

template

class

_Elem

class

_UTy

inline

_Elem

_UIntegral_to_buff

(

_Elem

_RNext

_UTy

_UVal

) {

// format _UVal into buffer *ending at* _RNext

static_assert

(

is_unsigned_v

_UTy

"_UTy must be unsigned"

);

#ifdef _WIN64

auto _UVal_trunc = _UVal;

#else /* ^^^ _WIN64 ^^^ // vvv !_WIN64 vvv */

#pragma warning(push)

#pragma warning(disable: 4127) // conditional expression is constant

#pragma warning(disable:

4127

)

(

sizeof

(

_UTy

) >

) {

// For 64-bit numbers, work in chunks to avoid 64-bit divisions.

while

(

_UVal

0xFFFFFFFFU

) {

auto

_UVal_chunk

static_cast

unsigned

long

_UVal

1000000000

);

_UVal

1000000000

;

for

(

int

_Idx

;

_Idx

; ++

_Idx

) { *--

_RNext

static_cast

_Elem

'0'

_UVal_chunk

);

_UVal_chunk

; } } } #pragma warning(pop)

auto

_UVal_trunc

static_cast

unsigned

long

_UVal

);

#endif /* _WIN64 */

{ *--

_RNext

static_cast

_Elem

'0'

_UVal_trunc

);

_UVal_trunc

; }

while

(

_UVal_trunc

);

return

(

_RNext

); }

template

class

_Elem

class

_Ty

inline

basic_string

_Elem

_Integral_to_string

(

const

_Ty

_Val

) {

// convert _Val to string

static_assert

(

is_integral_v

_Ty

"_Ty must be integral"

);

using

_UTy

make_unsigned_t

_Ty

_Elem

_Buff

[

];

// can hold -2^63 and 2^64 - 1, plus NUL

_Elem* const _Buff_end = _STD end(_Buff);

_Elem

const

_Buff_end

= ::

std

end

(

_Buff

);

_Elem

_RNext

_Buff_end

;

const

auto

_UVal

static_cast

_UTy

_Val

);

(

_Val

) {

_RNext

_UIntegral_to_buff

(

_RNext

_UVal

); *--

_RNext

'-'

; }

else

_RNext

_UIntegral_to_buff

(

_RNext

_UVal

);

return

(

basic_string

_Elem

_RNext

_Buff_end

)); }

template

class

_Ty

inline

string

_Floating_to_string

(

const

char

_Fmt

_Ty

_Val

) {

// convert _Val to string

static_assert

(

is_floating_point_v

_Ty

"_Ty must be floating point"

);

const auto _Len = static_cast<size_t>(_CSTD _scprintf(_Fmt, _Val));

const

auto

_Len

static_cast

size_t

>(::

_scprintf

(

_Fmt

_Val

));

string

_Str

(

_Len

'\0'

);

_CSTD sprintf_s(&_Str[0], _Len + 1, _Fmt, _Val);

sprintf_s

_Str

[

_Len

_Fmt

_Val

);

return

(

_Str

); }

template

class

_Ty

inline

wstring

_Floating_to_wstring

(

const

wchar_t

_Fmt

_Ty

_Val

) {

// convert _Val to wstring

static_assert

(

is_floating_point_v

_Ty

"_Ty must be floating point"

);

const auto _Len = static_cast<size_t>(_CSTD _scwprintf(_Fmt, _Val));

const

auto

_Len

static_cast

size_t

>(::

_scwprintf

(

_Fmt

_Val

));

wstring

_Str

(

_Len

L'\0'

);

_CSTD swprintf_s(&_Str[0], _Len + 1, _Fmt, _Val);

swprintf_s

_Str

[

_Len

_Fmt

_Val

);

return

(

_Str

); }

#undef _TO_STRING_BUF_SIZE

// to_string NARROW CONVERSIONS

_NODISCARD inline string to_string(int _Val)

inline

string

to_string

(

int

_Val

)

{

// convert int to string

return

(

_Integral_to_string

char

_Val

)); }

_NODISCARD inline string to_string(unsigned int _Val)

inline

string

to_string

(

unsigned

int

_Val

)

{

// convert unsigned int to string

return

(

_Integral_to_string

char

_Val

)); }

_NODISCARD inline string to_string(long _Val)

inline

string

to_string

(

long

_Val

)

{

// convert long to string

return

(

_Integral_to_string

char

_Val

)); }

_NODISCARD inline string to_string(unsigned long _Val)

inline

string

to_string

(

unsigned

long

_Val

)

{

// convert unsigned long to string

return

(

_Integral_to_string

char

_Val

)); }

_NODISCARD inline string to_string(long long _Val)

inline

string

to_string

(

long

_Val

)

{

// convert long long to string

return

(

_Integral_to_string

char

_Val

)); }

_NODISCARD inline string to_string(unsigned long long _Val)

inline

string

to_string

(

unsigned

long

_Val

)

{

// convert unsigned long long to string

return

(

_Integral_to_string

char

_Val

)); }

_NODISCARD inline string to_string(float _Val)

inline

string

to_string

(

float

_Val

)

{

// convert float to string

return

(

_Floating_to_string

(

"%f"

_Val

)); }

_NODISCARD inline string to_string(double _Val)

inline

string

to_string

(

double

_Val

)

{

// convert double to string

return

(

_Floating_to_string

(

"%f"

_Val

)); }

_NODISCARD inline string to_string(long double _Val)

inline

string

to_string

(

long

double

_Val

)

{

// convert long double to string

return

(

_Floating_to_string

(

"%Lf"

_Val

)); }

// to_wstring WIDE CONVERSIONS

_NODISCARD inline wstring to_wstring(int _Val)

inline

wstring

to_wstring

(

int

_Val

)

{

// convert int to wstring

return

(

_Integral_to_string

wchar_t

_Val

)); }

_NODISCARD inline wstring to_wstring(unsigned int _Val)

inline

wstring

to_wstring

(

unsigned

int

_Val

)

{

// convert unsigned int to wstring

return

(

_Integral_to_string

wchar_t

_Val

)); }

_NODISCARD inline wstring to_wstring(long _Val)

inline

wstring

to_wstring

(

long

_Val

)

{

// convert long to wstring

return

(

_Integral_to_string

wchar_t

_Val

)); }

_NODISCARD inline wstring to_wstring(unsigned long _Val)

inline

wstring

to_wstring

(

unsigned

long

_Val

)

{

// convert unsigned long to wstring

return

(

_Integral_to_string

wchar_t

_Val

)); }

_NODISCARD inline wstring to_wstring(long long _Val)

inline

wstring

to_wstring

(

long

_Val

)

{

// convert long long to wstring

return

(

_Integral_to_string

wchar_t

_Val

)); }

_NODISCARD inline wstring to_wstring(unsigned long long _Val)

inline

wstring

to_wstring

(

unsigned

long

_Val

)

{

// convert unsigned long long to wstring

return

(

_Integral_to_string

wchar_t

_Val

)); }

_NODISCARD inline wstring to_wstring(float _Val)

inline

wstring

to_wstring

(

float

_Val

)

{

// convert float to wstring

return

(

_Floating_to_wstring

(

L"%f"

_Val

)); }

_NODISCARD inline wstring to_wstring(double _Val)

inline

wstring

to_wstring

(

double

_Val

)

{

// convert double to wstring

return

(

_Floating_to_wstring

(

L"%f"

_Val

)); }

_NODISCARD inline wstring to_wstring(long double _Val)

inline

wstring

to_wstring

(

long

double

_Val

)

{

// convert long double to wstring

return

(

_Floating_to_wstring

(

L"%Lf"

_Val

)); }

// basic_string LITERALS

inline

namespace

literals

{

inline

namespace

string_literals

{

_NODISCARD inline string operator "" s(const char *_Str, size_t _Len)

inline

string

operator

(

const

char

_Str

size_t

_Len

)

{

// construct literal from [_Str, _Str + _Len)

return

(

string

(

_Str

_Len

)); }

_NODISCARD inline wstring operator "" s(const wchar_t *_Str, size_t _Len)

inline

wstring

operator

(

const

wchar_t

_Str

size_t

_Len

)

{

// construct literal from [_Str, _Str + _Len)

return

(

wstring

(

_Str

_Len

)); }

_NODISCARD inline u16string operator "" s(const char16_t *_Str, size_t _Len)

inline

u16string

operator

(

const

char16_t

_Str

size_t

_Len

)

{

// construct literal from [_Str, _Str + _Len)

return

(

u16string

(

_Str

_Len

)); }

_NODISCARD inline u32string operator "" s(const char32_t *_Str, size_t _Len)

inline

u32string

operator

(

const

char32_t

_Str

size_t

_Len

)

{

// construct literal from [_Str, _Str + _Len)

return

(

u32string

(

_Str

_Len

)); } }

// inline namespace string_literals

}

// inline namespace literals

#if _HAS_CXX17

namespace pmr {

template<class _Elem,

class _Traits = char_traits<_Elem>>

using basic_string = _STD basic_string<_Elem, _Traits, polymorphic_allocator<_Elem>>;

using string = basic_string<char>;

using u16string = basic_string<char16_t>;

using u32string = basic_string<char32_t>;

using wstring = basic_string<wchar_t>;

} // namespace pmr #endif /* _HAS_CXX17 */

_STD_END

}

#pragma pop_macro("new")

_STL_RESTORE_CLANG_WARNINGS

#pragma warning(pop)

#pragma pack(pop) #endif /* RC_INVOKED */ #endif /* _STRING_ */

#pragma pack(pop)