सी ++ में सीआईएन से ईओएफ तक कैसे पढ़ा जाए

Stdin से डेटा की एक परिवर्तनीय मात्रा को पढ़ने का एकमात्र तरीका लूप का उपयोग कर रहा है। मैंने हमेशा पाया है कि std :: getline() फ़ंक्शन बहुत अच्छी तरह से काम करता है:

std::string line;
while (std::getline(std::cin, line))
{
    std::cout << line << std::endl;
}

डिफ़ॉल्ट रूप से getline() एक नई लाइन तक पढ़ता है। आप एक वैकल्पिक समाप्ति चरित्र निर्दिष्ट कर सकते हैं, लेकिन ईओएफ स्वयं एक चरित्र नहीं है, इसलिए आप आसानी से getline() पर एक कॉल नहीं कर सकते हैं।

स्ट्रीम स्ट्रीमर का उपयोग कर आप स्पष्ट लूप के बिना इसे कर सकते हैं। मुझे यकीन है कि यह आंतरिक रूप से किसी प्रकार का पाश का उपयोग करता है।

#include 
#include 
#include 
#include 
#include 

int main()
{
// don't skip the whitespace while reading
  std::cin >> std::noskipws;

// use stream iterators to copy the stream to a string
  std::istream_iterator it(std::cin);
  std::istream_iterator end;
  std::string results(it, end);

  std::cout << results;
}

लूप का उपयोग करना:

#include 
using namespace std;
...
// numbers
int n;
while (cin >> n)
{
   ...
}
// lines
string line;
while (getline(cin, line))
{
   ...
}
// characters
char c;
while (cin.get(c))
{
   ...
}

संसाधन

std :: istream_iterator का उपयोग करके कीथबी के समाधान की खोज करने के बाद, मैंने < कोड> एसटीडी: istreambuf_iterator ।

एक स्ट्रिंग में सभी पाइप इनपुट को पढ़ने के लिए टेस्ट प्रोग्राम, फिर इसे फिर से लिखें:

#include 
#include 
#include 

int main()
{
  std::istreambuf_iterator begin(std::cin), end;
  std::string s(begin, end);
  std::cout << s;
}

संभव सरल और आम तौर पर कुशल:

#include 
int main()
{
    std::cout << std::cin.rdbuf();
}

यदि आवश्यक हो, तो मानक आउटपुट स्ट्रीम के बजाय std :: ostringstream जैसे अन्य प्रकार की स्ट्रीम का उपयोग करें।

आप std :: istream :: getline() का उपयोग कर सकते हैं ( या अधिमानतः संस्करण जो std :: string पर काम करता है) एक संपूर्ण रेखा प्राप्त करने के लिए फ़ंक्शन । दोनों में ऐसे संस्करण हैं जो आपको डिलीमीटर (रेखा वर्ण का अंत) निर्दिष्ट करने की अनुमति देते हैं। स्ट्रिंग संस्करण के लिए डिफ़ॉल्ट '\ n' है।

दुखद पक्ष नोट: मैंने बूस्ट आधारित कोड के अनुरूप होने के लिए सी ++ आईओ का उपयोग करने का निर्णय लिया। इस प्रश्न के उत्तर से मैंने जबकि (std :: getline (std :: cin, line) चुना है) । Cygwin (mintty) में g ++ संस्करण 4.5.3 (-O3) का उपयोग करके मुझे 2 एमबी/एस थ्रूपुट मिला। माइक्रोसॉफ्ट विजुअल सी ++ 2010 (/ ओ 2) ने इसे उसी कोड के लिए 40 एमबी/एस बनाया है।

आईओ को शुद्ध सी <कोड> को फिर से लिखने के बाद (fgets (buf, 100, stdin)) थ्रूपुट दोनों परीक्षण कंपाइलरों में 90 एमबी/एस तक कूद गया। इससे किसी भी इनपुट के लिए 10 एमबी से बड़ा अंतर होता है ...

while(std::cin) {
//do something
}

एक विकल्प एक कंटेनर का उपयोग करना है, उदा।

std::vector data;

और पुनर्निर्देशित इस संग्रह में सभी इनपुट EOF प्राप्त होने तक, यानी।

std::copy(std::istream_iterator(std::cin),
    std::istream_iterator(),
    std::back_inserter(data));

हालांकि, उपयोग किए गए कंटेनर को स्मृति को फिर से आवंटित करने की आवश्यकता हो सकती है, या जब आपका सिस्टम स्मृति से बाहर हो जाता है तो आप std :: bad_alloc अपवाद के साथ समाप्त हो जाएंगे। इन समस्याओं को हल करने के लिए, आप आरक्षित तत्वों की एक निश्चित राशि N कर सकते हैं और इन तत्वों को अलगाव में संसाधित कर सकते हैं, यानी।

data.reserve(N);    
while (/*some condition is met*/)
{
    std::copy_n(std::istream_iterator(std::cin),
        N,
        std::back_inserter(data));

    /* process data */

    data.clear();
}

रुको, क्या मैं आपको सही ढंग से समझ रहा हूँ? आप कुंजीपटल इनपुट के लिए सीन का उपयोग कर रहे हैं, और जब आप ईओएफ चरित्र में प्रवेश करते हैं तो आप इनपुट पढ़ने को रोकना चाहते हैं? उपयोगकर्ता कभी भी ईओएफ चरित्र में क्यों टाइप करेगा? या क्या आपका मतलब है कि आप ईओएफ में एक फाइल से पढ़ना बंद करना चाहते हैं?

यदि आप वास्तव में एक ईओएफ चरित्र पढ़ने के लिए सीन का उपयोग करने की कोशिश कर रहे हैं, तो क्यों न केवल ईओएफ को डिलीमीटर के रूप में निर्दिष्ट करें?

// Needed headers: iostream

char buffer[256];
cin.get( buffer, '\x1A' );

यदि आप ईओएफ पर किसी फ़ाइल से पढ़ना बंद करना चाहते हैं, तो बस गेटलाइन का उपयोग करें और एक बार फिर ईओएफ को डिलीमीटर के रूप में निर्दिष्ट करें।

// Needed headers: iostream, string, and fstream

string buffer;

    ifstream fin;
    fin.open("test.txt");
    if(fin.is_open()) {
        getline(fin,buffer,'\x1A');

        fin.close();
    }