Standardowe literały znakowe

[specyfikacja] Standardowe operatory-suffixy dla typów std::basic_string, std::chrono::duration<> i std::complex<>.

Składnia

Konwersja do std::complex<>

#include <complex>

namespace std
{
inline namespace literals
{
inline namespace complex_literals
{
constexpr std::complex < double > operator "" i( unsigned long long d );
constexpr std::complex < double > operator "" i( long double d );

constexpr std::complex < float > operator "" if( unsigned long long d );

constexpr std::complex < float > operator "" if( long double d );

constexpr std::complex < long double > operator "" il( unsigned long long d );
constexpr std::complex < long double > operator "" il( long double d );
}
}
}

Konwersja do std::string

#include <string>

namespace std
{
inline namespace literals
{
inline namespace string_literals
{
string operator "" s( const char * str, std::size_t len );
u16string operator "" s( const char16_t * str, std::size_t len );
u32string operator "" s( const char32_t * str, std::size_t len );
wstring operator "" s( const wchar_t * str, std::size_t len );
}
}
}

Konwersja do std::chrono::duration

#include <chrono>

namespace std
{
inline namespace literals
{
inline namespace chrono_literals
{
constexpr chrono::hours operator "" h( unsigned long long hrs );
constexpr chrono::duration < /*unspecified*/, ratio < 3600, 1 >> operator "" h( long double hrs );

constexpr chrono::minutes operator "" min( unsigned long long mins );
constexpr chrono::duration < /*unspecified*/, ratio < 60, 1 >> operator "" min( long double mins );

constexpr chrono::seconds operator "" s( unsigned long long secs );
constexpr chrono::duration < /*unspecified*/ > operator "" s( long double secs );

constexpr chrono::milliseconds operator "" ms( unsigned long long ms );
constexpr chrono::duration < /*unspecified*/, milli > operator "" ms( long double ms );

constexpr chrono::microseconds operator "" us( unsigned long long us );
constexpr chrono::duration < /*unspecified*/, micro > operator "" us( long double us );

constexpr chrono::nanoseconds operator "" ns( unsigned long long nsec );
constexpr chrono::duration < /*unspecified*/, nano > operator "" ns( long double nsec );
}
}
}

Opis szczegółowy

W C++11 pojawiła się możliwość definiowania własnych literałów, czyli własnych operatorów do konwersji z typów wbudowanych na dowolny typ przy pomocy suffixów-funkcji. Wraz z pojawieniem się C++14 pojawiły się przedefiniowane suffixy dla pewnych typów standardowych:

Szablon klasy	nazwy jego specjalizacji dla których dodano literały
std::basic_string <>	std::string std::wstring std::u16string std::u32string
std::complex <>	std::complex < double > std::complex < float > std::complex < long double >
std::duration <>	std::chrono::hours std::chrono::minutes std::chrono::seconds std::chrono::milliseconds std::chrono::microseconds std::chrono::nanoseconds

Dodatkowe informacje

W standardzie C++17 mają wejść jeszcze literały tworzące

std::string_view

, suffixy te to sv;

Rzucane wyjątki

Każdy z operatorów może wyrzucić wyjątek taki jak konstruktor danego obiektu, czyli:

Konstruowane obiekty	rzucany typ wyjątku
std::bacic_string <>	std::length_error i std::bad_alloc
std::complex <>	w razie zawężania liczby na niereprezentowalną występuje niezdefiniowane zachowanie
std::chrono::duration <>	(w dokumentacji nie znaleziono informacji o wyjątkach)

Przykładowa implementacja

Przykładowe implementacje literałów std::complex<>

Poniższe przykładowe implementacje cytuję ze strony http://en.cppreference.com/w/cpp/numeric/complex/operator%22%22i

constexpr std::complex < double > operator "" i( unsigned long long d )
{
return std::complex < double > { 0.0, static_cast < double >( d ) };
}
constexpr std::complex < double > operator "" i( long double d )
{
return std::complex < double > { 0.0, static_cast < double >( d ) };
}

constexpr std::complex < float > operator "" if( unsigned long long d )
{
return std::complex < float > { 0.0f, static_cast < float >( d ) };
}
constexpr std::complex < float > operator "" if( long double d )
{
return std::complex < float > { 0.0f, static_cast < float >( d ) };
}

constexpr std::complex < long double > operator "" il( unsigned long long d )
{
return std::complex < long double > { 0.0L, static_cast < long double >( d ) };
}
constexpr std::complex < long double > operator "" il( long double d )
{
return std::complex < long double > { 0.0L, d };
}

Przykładowe implementacje literałów tekstowych

std::string operator "" s( const char * str, std::size_t len )
{
return std::string( str, len );
}
std::u16string operator "" s( const char16_t * str, std::size_t len )
{
return std::u16string( str, len );
}
std::u32string operator "" s( const char32_t * str, std::size_t len )
{
return std::u32string( str, len );
}
std::wstring operator "" s( const wchar_t * str, std::size_t len )
{
return std::wstring( str, len );
}

Przykładowe implementacje literałów std::chrono::duration

Poniższe przykładowe implementacje cytuję ze stron http://en.cppreference.com/w/cpp/chrono/operator%22%22h, http://en.cppreference.com/w/cpp/chrono/operator%22%22min, http://en.cppreference.com/w/cpp/chrono/operator%22%22s, http://en.cppreference.com/w/cpp/chrono/operator%22%22ms, http://en.cppreference.com/w/cpp/chrono/operator%22%22us, http://en.cppreference.com/w/cpp/chrono/operator%22%22ns:

constexpr std::chrono::hours operator "" h( unsigned long long h )
{
return std::chrono::hours( h );
}
constexpr std::chrono::duration < long double, ratio < 3600, 1 >> operator "" h( long double h )
{
return std::chrono::duration < long double, std::ratio < 3600, 1 >>( h );
}

constexpr std::chrono::minutes operator "" min( unsigned long long m )
{
return std::chrono::minutes( m );
}
constexpr std::chrono::duration < long double, std::ratio < 60, 1 >> operator "" min( long double m )
{
return std::chrono::duration < long double, ratio < 60, 1 >>( m );
}

constexpr std::chrono::seconds operator "" s( unsigned long long s )
{
return std::chrono::seconds( s );
}
constexpr std::chrono::duration < long double > operator "" s( long double s )
{
return std::chrono::duration < long double >( s );
}

constexpr std::chrono::milliseconds operator "" ms( unsigned long long ms )
{
return chrono::milliseconds( ms );
}
constexpr std::chrono::duration < long double, std::milli > operator "" ms( long double ms )
{
return std::chrono::duration < long double, std::milli >( ms );
}

constexpr std::chrono::microseconds operator "" us( unsigned long long us )
{
return std::chrono::microseconds( us );
}
constexpr std::chrono::duration < long double, std::micro > operator "" us( long double us )
{
return std::chrono::duration < long double, std::micro >( us );
}

constexpr std::chrono::nanoseconds operator "" ns( unsigned long long ns )
{
return chrono::nanoseconds( ns );
}
constexpr std::chrono::duration < long double, std::nano > operator "" ns( long double ns )
{
return std::chrono::duration < long double, std::nano >( ns );
}

Przykład

#include <iostream>
#include <string>
#include <typeinfo> // typeid
#include <chrono> // seconds
#include <complex>

int main()
{
auto text = "Ala ma psa" s;
if( typeid( std::string ) == typeid( text ) )
{
cout << "It is std::string: " << text << endl;
}

auto seconds = 10s;
if( typeid( std::chrono::seconds ) == typeid( seconds ) )
{
cout << "It is std::chrono::seconds: " << seconds.count() << endl;
}

auto complexNumber = 2.+ 4.2i;
if( typeid( std::complex < double > ) == typeid( complexNumber ) )
{
cout << "It is std::complex<double>: " << complexNumber.real() << " + " << complexNumber.imag() << "i" << endl;
}
}

Standardowe wyjście programu:

It is std::string: Ala ma psa
It is std::chrono::seconds: 10
It is std::complex<double>: 2 + 4.2i

Zagadnienia powiązane

string	Przechowuje tekst wielobajtowy. Znak jest zdefiniowany za pomocą typu char . (alias)
wstring	Przechowuje tekst unikodowy. Znak jest zdefiniowany za pomocą typu wchar_t . (alias)

Linki zewnętrzne

Wszystkie teksty są chronione prawami autorskimi. Kopiowanie lub rozpowszechnianie treści poza niniejszym serwisem jest zabronione.

Powyższe ograniczenie nie dotyczy autora opracowania, któremu przysługuje prawo do rozpowszechniania własnego tekstu wedle własnego uznania.