« Standardowe literały znakowe, specyfikacja, C++ »
Standardowe literały znakowe - Standardowe operatory-suffixy dla typów std::basic_string, std::chrono::duration<> i std::complex<>. (specyfikacja)
Panel użytkownika
Nazwa użytkownika:
Hasło:
Nie masz jeszcze konta?
Zarejestruj się!
Hasło nie zostało zweryfikowane
Niniejsze hasło zostało opracowane, jednak nie zostało ono zweryfikowane przez administrację serwisu. Jeżeli znalazłeś błędy merytoryczne w niniejszym dokumencie, prosimy o ich zgłoszenie na forum w dziale Znalezione błędy.
Opracował: baziorek
« Standard C++14 »

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<>

C/C++
#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

C/C++
#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

C/C++
#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 klasynazwy 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 obiektyrzucany 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
C/C++
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

C/C++
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:
C/C++
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

C/C++
#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

stringPrzechowuje tekst wielobajtowy. Znak jest zdefiniowany za pomocą typu
char
. (alias)
wstringPrzechowuje tekst unikodowy. Znak jest zdefiniowany za pomocą typu
wchar_t
. (alias)

Linki zewnętrzne