खोज…


उपयोगकर्ता-परिभाषित शाब्दिक लंबे दोहरे मूल्यों के साथ

#include <iostream>

long double operator"" _km(long double val)
{
    return val * 1000.0;
}

long double operator"" _mi(long double val)
{
    return val * 1609.344;
}

int main()
{
    std::cout << "3 km = " << 3.0_km << " m\n";
    std::cout << "3 mi = " << 3.0_mi << " m\n";
    return 0;
}

इस कार्यक्रम का आउटपुट निम्नलिखित है:

3 km = 3000 m
3 mi = 4828.03 m

अवधि के लिए मानक उपयोगकर्ता-परिभाषित शाब्दिक

सी ++ 14

निम्नलिखित अवधि उपयोगकर्ता शाब्दिक namespace std::literals::chrono_literals में घोषित किए गए हैं std::literals::chrono_literals , जहाँ literals और chrono_literals इनलाइन नामस्थान हैं । इन ऑपरेटरों तक पहुंच using namespace std::literals , using namespace std::chrono_literals , और using namespace std::chrono_literals using namespace std::literals::chrono_literals using namespace std::literals प्राप्त की जा सकती है।

#include <chrono>
#include <iostream>

int main()
{
    using namespace std::literals::chrono_literals;

    std::chrono::nanoseconds t1 = 600ns;
    std::chrono::microseconds t2 = 42us;
    std::chrono::milliseconds t3 = 51ms;
    std::chrono::seconds t4 = 61s;
    std::chrono::minutes t5 = 88min;
    auto t6 = 2 * 0.5h;

    auto total = t1 + t2 + t3 + t4 + t5 + t6;

    std::cout.precision(13);
    std::cout << total.count() << " nanoseconds" << std::endl; // 8941051042600 nanoseconds
    std::cout << std::chrono::duration_cast<std::chrono::hours>(total).count()
              << " hours" << std::endl; // 2 hours
}

स्ट्रिंग के लिए मानक उपयोगकर्ता-परिभाषित शाब्दिक

सी ++ 14

निम्नलिखित स्ट्रिंग उपयोगकर्ता शाब्दिक namespace std::literals::string_literals में घोषित किए गए हैं std::literals::string_literals , जहाँ literals और string_literals दोनों इनलाइन नेमस्पेस हैं । इन ऑपरेटरों तक पहुंच using namespace std::literals , using namespace std::string_literals , और using namespace std::literals::string_literals using namespace std::literals प्राप्त की जा सकती है।

#include <codecvt>
#include <iostream>
#include <locale>
#include <string>

int main()
{
    using namespace std::literals::string_literals;

    std::string s = "hello world"s;
    std::u16string s16 = u"hello world"s;
    std::u32string s32 = U"hello world"s;
    std::wstring ws = L"hello world"s;
    
    std::cout << s << std::endl;

    std::wstring_convert<std::codecvt_utf8_utf16<char16_t>, char16_t> utf16conv;
    std::cout << utf16conv.to_bytes(s16) << std::endl;

    std::wstring_convert<std::codecvt_utf8_utf16<char32_t>, char32_t> utf32conv;
    std::cout << utf32conv.to_bytes(s32) << std::endl;

    std::wcout << ws << std::endl;
}

ध्यान दें:

शाब्दिक स्ट्रिंग \0 युक्त हो सकता है

std::string s1 = "foo\0\0bar";  // constructor from C-string: results in "foo"s
std::string s2 = "foo\0\0bar"s; // That string contains 2 '\0' in its middle

जटिल के लिए मानक उपयोगकर्ता-परिभाषित शाब्दिक

सी ++ 14

निम्नलिखित जटिल उपयोगकर्ता शाब्दिक namespace std::literals::complex_literals में घोषित किए गए हैं std::literals::complex_literals , जहाँ literals और complex_literals दोनों इनलाइन नामस्थान हैं । इन ऑपरेटरों तक पहुंच using namespace std::literals , using namespace std::literals प्राप्त की जा सकती है using namespace std::complex_literals , और using namespace std::literals::complex_literals

#include <complex>
#include <iostream>

int main()
{
    using namespace std::literals::complex_literals;
    
    std::complex<double> c = 2.0 + 1i;        // {2.0, 1.}
    std::complex<float> cf = 2.0f + 1if;      // {2.0f, 1.f}
    std::complex<long double> cl = 2.0L + 1il; // {2.0L, 1.L}
    
    std::cout << "abs" << c << " = " << abs(c) << std::endl;   // abs(2,1) = 2.23607
    std::cout << "abs" << cf << " = " << abs(cf) << std::endl; // abs(2,1) = 2.23607
    std::cout << "abs" << cl << " = " << abs(cl) << std::endl; // abs(2,1) = 2.23607
}

बाइनरी के लिए स्व-निर्मित उपयोगकर्ता-परिभाषित शाब्दिक

बावजूद आप C ++ 14 में एक बाइनरी नंबर लिख सकते हैं जैसे:

int number =0b0001'0101; // ==21

यहां बाइनरी संख्याओं के लिए स्व-निर्मित कार्यान्वयन के साथ एक प्रसिद्ध उदाहरण आता है:

नोट: संपूर्ण टेम्पलेट विस्तार कार्यक्रम संकलन समय पर चल रहा है।

template< char FIRST, char... REST > struct binary
{
    static_assert( FIRST == '0' || FIRST == '1', "invalid binary digit" ) ;
    enum { value = ( ( FIRST - '0' ) << sizeof...(REST) ) + binary<REST...>::value  } ;
};

template<> struct binary<'0'> { enum { value = 0 } ; };
template<> struct binary<'1'> { enum { value = 1 } ; };


// raw literal operator
template<  char... LITERAL > inline
constexpr unsigned int operator "" _b() { return binary<LITERAL...>::value ; }

// raw literal operator
template<  char... LITERAL > inline
constexpr unsigned int operator "" _B() { return binary<LITERAL...>::value ; }

#include <iostream>

int main()
{
    std::cout  << 10101_B << ", " << 011011000111_b  << '\n' ; // prints 21, 1735
}


Modified text is an extract of the original Stack Overflow Documentation
के तहत लाइसेंस प्राप्त है CC BY-SA 3.0
से संबद्ध नहीं है Stack Overflow