C++
स्ट्रीम मैनिपुलेटर

परिचय

टिप्पणियों

str.setf(base ==  8 ? std::ios_base::oct :
            base == 10 ? std::ios_base::dec :
                base == 16 ? std::ios_base::hex :
                     std::ios_base::fmtflags(0),
         std::ios_base::basefield);

स्ट्रीम मैनिपुलेटर

std::boolalpha और std::noboolalpha - std::noboolalpha और संख्यात्मक प्रतिनिधित्व के बीच स्विच।

std::cout << std::boolalpha << 1;
// Output: true

std::cout << std::noboolalpha << false;
// Output: 0

bool boolValue;
std::cin >> std::boolalpha >> boolValue;
std::cout << "Value \"" << std::boolalpha << boolValue
          << "\" was parsed as " << std::noboolalpha << boolValue;
// Input: true
// Output: Value "true" was parsed as 0

std::showbase और std::noshowbase - यह नियंत्रित करता है कि क्या संख्यात्मक आधार का संकेत उपसर्ग उपयोग किया जाता है।

std::dec (दशमलव), std::hex (हेक्साडेसिमल) और std::oct (ओक्टल) - पूर्णांक के लिए आधार बदलने के लिए उपयोग किया जाता है।

#include <sstream>

std::cout << std::dec << 29 << ' - '
          << std::hex << 29 << ' - '
          << std::showbase << std::oct << 29 << ' - '
          << std::noshowbase << 29  '\n';
int number;
std::istringstream("3B") >> std::hex >> number;
std::cout << std::dec << 10;
// Output: 22 - 1D - 35 - 035
// 59

डिफ़ॉल्ट मान std::ios_base::noshowbase और std::ios_base::dec ।

यदि आप std::istringstream बारे में और देखना चाहते हैं तो < sstream > हैडर देखें।

std::uppercase और std::nouppercase - नियंत्रण है कि अपरकेस वर्णों का उपयोग फ्लोटिंग-पॉइंट और हेक्साडेसिमल पूर्णांक आउटपुट में किया जाता है। इनपुट धाराओं पर कोई प्रभाव नहीं है।

std::cout << std::hex << std::showbase
              << "0x2a with nouppercase: " << std::nouppercase << 0x2a << '\n'
              << "1e-10 with uppercase: " << std::uppercase << 1e-10 << '\n'
}
// Output: 0x2a with nouppercase: 0x2a
// 1e-10 with uppercase: 1E-10

डिफ़ॉल्ट std::nouppercase ।

std::setw(n) - अगले इनपुट / आउटपुट फ़ील्ड की चौड़ाई को बिल्कुल n बदलता है।

चौड़ाई गुण n 0 रीसेट हो रहा है जब कुछ फ़ंक्शन कहा जाता है (पूरी सूची यहां है )।

std::cout << "no setw:" << 51 << '\n'
          << "setw(7): " << std::setw(7) << 51 << '\n'
          << "setw(7), more output: " << 13
          << std::setw(7) << std::setfill('*') << 67 << ' ' << 94 << '\n';

char* input = "Hello, world!";
char arr[10];
std::cin >> std::setw(6) >> arr;
std::cout << "Input from \"Hello, world!\" with setw(6) gave \"" << arr << "\"\n";

// Output: 51
// setw(7):      51
// setw(7), more output: 13*****67 94

// Input: Hello, world!
// Output: Input from "Hello, world!" with setw(6) gave "Hello"

डिफ़ॉल्ट std::setw(0) ।

std::left , std::right और std::internal - std::ios_base::adjustfield सेट करके वर्णों की डिफ़ॉल्ट स्थिति को संशोधित करें std::ios_base::adjustfield करने के लिए std::ios_base::left , std::ios_base::right और std::ios_base::internal । std::left और std::right किसी भी आउटपुट पर लागू होता है, std::internal - पूर्णांक, फ्लोटिंग-पॉइंट और मौद्रिक आउटपुट के लिए। इनपुट धाराओं पर कोई प्रभाव नहीं है।

#include <locale>
...

std::cout.imbue(std::locale("en_US.utf8"));

std::cout << std::left << std::showbase << std::setfill('*')
          << "flt: " << std::setw(15) << -9.87  << '\n'
          << "hex: " << std::setw(15) << 41 << '\n'
          << "  $: " << std::setw(15) << std::put_money(367, false) << '\n'
          << "usd: " << std::setw(15) << std::put_money(367, true) << '\n'
          << "usd: " << std::setw(15)
          << std::setfill(' ') << std::put_money(367, false) << '\n';
// Output:
// flt: -9.87**********
// hex: 41*************
//   $: $3.67**********
// usd: USD *3.67******
// usd: $3.67          

std::cout << std::internal << std::showbase << std::setfill('*')
          << "flt: " << std::setw(15) << -9.87  << '\n'
          << "hex: " << std::setw(15) << 41 << '\n'
          << "  $: " << std::setw(15) << std::put_money(367, false) << '\n'
          << "usd: " << std::setw(15) << std::put_money(367, true) << '\n'
          << "usd: " << std::setw(15)
          << std::setfill(' ') << std::put_money(367, true) << '\n';
// Output:
// flt: -**********9.87
// hex: *************41
//   $: $3.67**********
// usd: USD *******3.67
// usd: USD        3.67

std::cout << std::right << std::showbase << std::setfill('*')
          << "flt: " << std::setw(15) << -9.87  << '\n'
          << "hex: " << std::setw(15) << 41 << '\n'
          << "  $: " << std::setw(15) << std::put_money(367, false) << '\n'
          << "usd: " << std::setw(15) << std::put_money(367, true) << '\n'
          << "usd: " << std::setw(15)
          << std::setfill(' ') << std::put_money(367, true) << '\n';
// Output:
// flt: **********-9.87
// hex: *************41
//   $: **********$3.67
// usd: ******USD *3.67
// usd:       USD  3.67

डिफ़ॉल्ट std::left ।

std::fixed , std::scientific , std::hexfloat [C ++ 11] और std::defaultfloat [C ++ 11] - फ़्लोटिंग-पॉइंट इनपुट / आउटपुट के लिए स्वरूपण बदलें।

std::fixed सेट std::ios_base::floatfield to std::ios_base::fixed ,
std::scientific - to std::ios_base::scientific ,
std::hexfloat - to std::ios_base::fixed | std::ios_base::scientific और
std::defaultfloat - to std::ios_base::fmtflags(0) ।

fmtflags

#include <sstream>
...

std::cout << '\n'
          << "The number 0.07 in fixed:      " << std::fixed << 0.01 << '\n'
          << "The number 0.07 in scientific: " << std::scientific << 0.01 << '\n'
          << "The number 0.07 in hexfloat:   " << std::hexfloat << 0.01 << '\n'
          << "The number 0.07 in default:    " << std::defaultfloat << 0.01 << '\n';

double f;
std::istringstream is("0x1P-1022");
double f = std::strtod(is.str().c_str(), NULL);
std::cout << "Parsing 0x1P-1022 as hex gives " << f << '\n';

// Output:
// The number 0.01 in fixed:      0.070000
// The number 0.01 in scientific: 7.000000e-02
// The number 0.01 in hexfloat:   0x1.1eb851eb851ecp-4
// The number 0.01 in default:    0.07
// Parsing 0x1P-1022 as hex gives 2.22507e-308

डिफ़ॉल्ट std::ios_base::fmtflags(0) ।

कुछ संकलक पर एक बग है जो कारण बनता है

double f;
std::istringstream("0x1P-1022") >> std::hexfloat >> f;
std::cout << "Parsing 0x1P-1022 as hex gives " << f << '\n';
// Output: Parsing 0x1P-1022 as hex gives 0

std::showpoint और std::noshowpoint - नियंत्रित करें कि क्या दशमलव बिंदु हमेशा फ्लोटिंग-पॉइंट प्रतिनिधित्व में शामिल है। इनपुट धाराओं पर कोई प्रभाव नहीं है।

std::cout << "7.0 with showpoint: " << std::showpoint << 7.0 << '\n'
          << "7.0 with noshowpoint: " << std::noshowpoint << 7.0 << '\n';
// Output: 1.0 with showpoint: 7.00000
// 1.0 with noshowpoint: 7

डिफ़ॉल्ट std::showpoint ।

std::showpos और std::noshowpos - गैर-नकारात्मक आउटपुट में + चिह्न के नियंत्रण को प्रदर्शित करता है। इनपुट धाराओं पर कोई प्रभाव नहीं है।

std::cout << "With showpos: " << std::showpos
          << 0 << ' ' << -2.718 << ' ' << 17 << '\n'
          << "Without showpos: " << std::noshowpos
          << 0 << ' ' << -2.718 << ' ' << 17 << '\n';
// Output: With showpos: +0 -2.718 +17
// Without showpos: 0 -2.718 17

डिफ़ॉल्ट अगर std::noshowpos ।

std::unitbuf , std::nounitbuf - हर ऑपरेशन के बाद फ्लशिंग आउटपुट स्ट्रीम को नियंत्रित करता है। इनपुट स्ट्रीम पर कोई प्रभाव नहीं है। std::unitbuf फ्लशिंग का कारण बनता है।

std::setbase(base) - स्ट्रीम का न्यूमेरिक बेस सेट करता है।

std::setbase(8) std::ios_base::basefield सेट करने के बराबर है std::ios_base::basefield to std::ios_base::oct ,
std::setbase(16) - से std::ios_base::hex ,
std::setbase(10) - से std::ios_base::dec ।

यदि base अन्य है तो 8 , 10 या 16 तब std::ios_base::basefield , std::ios_base::fmtflags(0) । इसका मतलब दशमलव उत्पादन और उपसर्ग-निर्भर इनपुट है।

डिफॉल्ट std::ios_base::basefield is std::ios_base::dec तो डिफ़ॉल्ट std::setbase(10) ।

std::setprecision(n) - फ्लोटिंग-पॉइंट परिशुद्धता को बदलता है।

#include <cmath>
#include <limits>
...

typedef std::numeric_limits<long double> ld;
const long double pi = std::acos(-1.L);

std::cout << '\n'
          << "default precision (6):   pi: " << pi << '\n'
          << "                       10pi: " << 10 * pi << '\n'
          << "std::setprecision(4):  10pi: " << std::setprecision(4) << 10 * pi << '\n'
          << "                    10000pi: " << 10000 * pi << '\n'
          << "std::fixed:         10000pi: " << std::fixed << 10000 * pi << std::defaultfloat << '\n'
          << "std::setprecision(10):   pi: " << std::setprecision(10) << pi << '\n'
          << "max-1 radix precicion:   pi: " << std::setprecision(ld::digits - 1) << pi << '\n'
          << "max+1 radix precision:   pi: " << std::setprecision(ld::digits + 1) << pi << '\n'
          << "significant digits prec: pi: " << std::setprecision(ld::digits10) << pi << '\n';

// Output:
// default precision (6):   pi: 3.14159
//                        10pi: 31.4159
// std::setprecision(4):  10pi: 31.42
//                     10000pi: 3.142e+04
// std::fixed:         10000pi: 31415.9265
// std::setprecision(10):   pi: 3.141592654
// max-1 radix precicion:   pi: 3.14159265358979323851280895940618620443274267017841339111328125
// max+1 radix precision:   pi: 3.14159265358979323851280895940618620443274267017841339111328125
// significant digits prec: pi: 3.14159265358979324

डिफ़ॉल्ट std::setprecision(6) ।

std::setiosflags(mask) और std::resetiosflags(mask) - std::ios_base::fmtflags mask में निर्दिष्ट और स्पष्ट झंडे std::ios_base::fmtflags प्रकार।

#include <sstream>
...

std::istringstream in("10 010 10 010 10 010");
int num1, num2;

in >> std::oct >> num1 >> num2;
std::cout << "Parsing \"10 010\" with std::oct gives:   " << num1 << ' ' << num2 << '\n';
// Output: Parsing "10 010" with std::oct gives:   8 8

in >> std::dec >> num1 >> num2;
std::cout << "Parsing \"10 010\" with std::dec gives:   " << num1 << ' ' << num2 << '\n';
// Output: Parsing "10 010" with std::oct gives:   10 10

in >> std::resetiosflags(std::ios_base::basefield) >> num1 >> num2;
std::cout << "Parsing \"10 010\" with autodetect gives: " << num1 << ' ' << num2 << '\n';
// Parsing "10 010" with autodetect gives: 10 8

std::cout << std::setiosflags(std::ios_base::hex |
                              std::ios_base::uppercase |
                              std::ios_base::showbase) << 42 << '\n';
// Output: OX2A

std::skipws और std::noskipws - स्वरूपित इनपुट फ़ंक्शंस द्वारा अग्रणी std::noskipws नियंत्रण को नियंत्रित करता है। आउटपुट स्ट्रीम पर कोई प्रभाव नहीं है।

#include <sstream>
...

char c1, c2, c3;
std::istringstream("a b c") >> c1 >> c2 >> c3;
std::cout << "Default  behavior:  c1 = " << c1 << "  c2 = " << c2 << "  c3 = " << c3 << '\n';

std::istringstream("a b c") >> std::noskipws >> c1 >> c2 >> c3;
std::cout << "noskipws behavior:  c1 = " << c1 << "  c2 = " << c2 << "  c3 = " << c3 << '\n';
// Output: Default  behavior:  c1 = a  c2 = b  c3 = c
// noskipws behavior:  c1 = a  c2 =    c3 = b

डिफ़ॉल्ट std::ios_base::skipws ।

std::quoted(s[, delim[, escape]]) [C ++ 14] - आवेषण या अर्क एम्बेडेड स्थानों के साथ उद्धृत तार।

s - डालने या निकालने के लिए स्ट्रिंग।
delim - चरित्र परिसीमक के रूप में उपयोग करने के लिए, " डिफ़ॉल्ट रूप से।
escape - चरित्र, भागने चरित्र के रूप में उपयोग करने के लिए \ डिफ़ॉल्ट रूप से।

#include <sstream>
...
 
std::stringstream ss;
std::string in = "String with spaces, and embedded \"quotes\" too";
std::string out;
 
ss << std::quoted(in);
std::cout << "read in     [" << in << "]\n"
          << "stored as   [" << ss.str() << "]\n";
 
ss >> std::quoted(out);
std::cout << "written out [" << out << "]\n";
// Output:
// read in     [String with spaces, and embedded "quotes" too]
// stored as   ["String with spaces, and embedded \"quotes\" too"]
// written out [String with spaces, and embedded "quotes" too]

अधिक जानकारी के लिए ऊपर दिए गए लिंक को देखें।

आउटपुट स्ट्रीम मैनिपुलेटर

std::ends - आउटपुट स्ट्रीम में एक अशक्त वर्ण '\0' सम्मिलित करता है। औपचारिक रूप से यह जोड़तोड़ की घोषणा की तरह दिखता है

template <class charT, class traits>
std::basic_ostream<charT, traits>& ends(std::basic_ostream<charT, traits>& os);

और यह मैनिप्युलेटर एक अभिव्यक्ति में इस्तेमाल होने पर os.put(charT()) को कॉल करके वर्ण os.put(charT())
os << std::ends;

std::endl और std::flush दोनों फ्लश उत्पादन स्ट्रीम out फोन करके out.flush() यह तुरंत उत्पादन का कारण बनता है। लेकिन std::endl से पहले लाइन '\n' सिंबल का अंत सम्मिलित करता है।

std::cout << "First line." << std::endl << "Second line. " << std::flush
          << "Still second line.";
// Output: First line.
// Second line. Still second line.

std::setfill(c) - भरण वर्ण को c बदलता है। अक्सर std::setw साथ प्रयोग किया जाता है।

std::cout << "\nDefault fill: " << std::setw(10) << 79 << '\n'
          << "setfill('#'): " << std::setfill('#')
          << std::setw(10) << 42 << '\n';
// Output:
// Default fill:         79
// setfill('#'): ########79

std::put_money(mon[, intl]) [C ++ 11]। एक अभिव्यक्ति में out << std::put_money(mon, intl) , मौद्रिक मान mon ( long double या std::basic_string प्रकार) को अपने वर्ण प्रतिनिधित्व के अनुसार std::money_put करता है जैसा कि std::money_put द्वारा निर्दिष्ट किया गया है std::money_put facet of the locale वर्तमान में imbued है out । अंतरराष्ट्रीय मुद्रा तार का उपयोग करें यदि intl true , तो मुद्रा प्रतीकों का उपयोग करें अन्यथा।

long double money = 123.45;
// or std::string money = "123.45";
 
std::cout.imbue(std::locale("en_US.utf8"));
std::cout << std::showbase << "en_US: " << std::put_money(money)
          << " or " << std::put_money(money, true) << '\n';
// Output: en_US: $1.23 or USD  1.23
 
std::cout.imbue(std::locale("ru_RU.utf8"));
std::cout << "ru_RU: " << std::put_money(money)
          << " or " << std::put_money(money, true) << '\n';
// Output: ru_RU: 1.23 руб or 1.23 RUB 
 
std::cout.imbue(std::locale("ja_JP.utf8"));
std::cout << "ja_JP: " << std::put_money(money)
          << " or " << std::put_money(money, true) << '\n';
// Output: ja_JP: ￥123 or JPY  123

std::put_time(tmb, fmt) [C ++ 11] - प्रारूप और आउटपुट दिनांक / समय मान std::tm निर्दिष्ट प्रारूप fmt अनुसार।

tmb - कैलेंडर समय संरचना के लिए संकेत const std::tm* जैसा कि localtime() या gmtime() से प्राप्त होता है।
fmt - एक अशक्त-टर्मिनेटेड स्ट्रिंग const CharT* रूपांतरण के प्रारूप को निर्दिष्ट करता है।

#include <ctime>
...

std::time_t t = std::time(nullptr);
std::tm tm = *std::localtime(&t);

std::cout.imbue(std::locale("ru_RU.utf8"));
std::cout << "\nru_RU: " << std::put_time(&tm, "%c %Z") << '\n';
// Possible output:
// ru_RU: Вт 04 июл 2017 15:08:35 UTC

अधिक जानकारी के लिए ऊपर दिए गए लिंक को देखें।

इनपुट स्ट्रीम जोड़तोड़

std::ws - इनपुट स्ट्रीम में अग्रणी व्हाट्सएप का उपभोग करता है। यह std::skipws से अलग है।

#include <sstream>
...

std::string str;
std::istringstream("  \v\n\r\t    Wow!There   is no whitespaces!") >> std::ws >> str;
std::cout << str;
// Output: Wow!There   is no whitespaces!

std::get_money(mon[, intl]) [C ++ 11]। in >> std::get_money(mon, intl) में एक अभिव्यक्ति in >> std::get_money(mon, intl) चरित्र इनपुट को एक मौद्रिक मूल्य के रूप में देखा जाता है, जैसा कि std::money_get द्वारा निर्दिष्ट किया गया है std::money_get facet of the locale वर्तमान में imbued in , और mon में मान को संग्रहीत करता है ( long double या std::basic_string प्रकार)। जोड़तोड़ की उम्मीद अंतरराष्ट्रीय मुद्रा तार की आवश्यकता है, तो intl है true है, अन्यथा वैकल्पिक मुद्रा प्रतीकों की उम्मीद है।

#include <sstream>
#include <locale>
...
 
std::istringstream in("$1,234.56 2.22 USD  3.33");
long double v1, v2;
std::string v3;

in.imbue(std::locale("en_US.UTF-8"));
in >> std::get_money(v1) >> std::get_money(v2) >> std::get_money(v3, true);
if (in) {
    std::cout << std::quoted(in.str()) << " parsed as: "
              << v1 << ", " << v2 << ", " << v3 << '\n';
}
// Output:
// "$1,234.56 2.22 USD  3.33" parsed as: 123456, 222, 333

std::get_time(tmb, fmt) [C ++ 11] - निर्दिष्ट प्रारूप fmt tmb में संग्रहीत दिनांक / समय मान को पार्स करता है।

tmb - const std::tm* लिए मान्य पॉइंटर const std::tm* ऑब्जेक्ट जहां रिजल्ट स्टोर किया जाएगा।
fmt - एक अशक्त-टर्मिनेटेड स्ट्रिंग const CharT* रूपांतरण प्रारूप को निर्दिष्ट करता है।

#include <sstream>
#include <locale>
...

std::tm t = {};
std::istringstream ss("2011-Februar-18 23:12:34");

ss.imbue(std::locale("de_DE.utf-8"));
ss >> std::get_time(&t, "%Y-%b-%d %H:%M:%S");
if (ss.fail()) {
    std::cout << "Parse failed\n";
}
else {
    std::cout << std::put_time(&t, "%c") << '\n';
}
// Possible output:
// Sun Feb 18 23:12:34 2011

अधिक जानकारी के लिए ऊपर दिए गए लिंक को देखें।