istringstream में फ़ाइल सामग्री को कैसे पढ़ा जाए?

Question

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

मेरा प्रश्न है, इस जानकारी को पढ़ने और स्ट्रिंग स्ट्रीम में "इसे आयात" करने का सबसे अच्छा तरीका कौन सा है? इस दृष्टिकोण के साथ एक समस्या (देखें) यह है कि जब स्ट्रिंग स्ट्रीम बनाते हैं तो बफर कॉपी हो जाते हैं, और मेमोरी उपयोग युगल होता है।

#include <fstream> 
#include <sstream> 

using namespace std; 

int main() { 
    ifstream is; 
    is.open (sFilename.c_str(), ios::binary); 

    // get length of file: 
    is.seekg (0, std::ios::end); 
    long length = is.tellg(); 
    is.seekg (0, std::ios::beg); 

    // allocate memory: 
    char *buffer = new char [length]; 

    // read data as a block: 
    is.read (buffer,length); 

    // create string stream of memory contents 
    // NOTE: this ends up copying the buffer!!! 
    istringstream iss(string(buffer)); 

    // delete temporary buffer 
    delete [] buffer; 

    // close filestream 
    is.close(); 

    /* ================================== 
    * Use iss to access data 
    */ 

} 

Answer 1

std::ifstream एक विधि rdbuf(), कि एक filebuf के लिए सूचक रिटर्न है। टिप्पणी में मार्टिन यॉर्क में टिप्पणी, इस के बाद से stringstream के operator<< चरित्र द्वारा filebuf चरित्र पढ़ा जाएगा सबसे तेजी से समाधान नहीं हो सकता है के रूप में: तब आप अपने stringstream में इस filebuf "धक्का" कर सकते हैं:

int main() 
{ 
    std::ifstream file("myFile"); 

    if (file) 
    { 
     std::stringstream buffer; 

     buffer << file.rdbuf(); 

     file.close(); 

     // operations on the buffer... 
    } 
} 

संपादित करें। हो सकता है कि आप उसका जवाब देखना चाहें, जहां वह ifstream की read विधि का उपयोग करता है जैसा कि आप करते थे, और उसके बाद stringstream बफर को पहले आवंटित स्मृति को इंगित करने के लिए सेट करें।

Answer 2

यह मेरे लिए समयपूर्व अनुकूलन की तरह लगता है। प्रसंस्करण में कितना काम किया जा रहा है। एक आधुनिक डेस्कटॉप/सर्वर मानना, और एक एम्बेडेड सिस्टम नहीं, इंटिलाइजेशन के दौरान कुछ एमबी डेटा कॉपी करना काफी सस्ते है, खासकर डिस्क की फाइल को पहले स्थान पर पढ़ने की तुलना में। मैं आपके पास जो कुछ भी रखता हूं उसके साथ रहूंगा, सिस्टम को पूरा होने पर मापें, और यह तय करें कि संभावित प्रदर्शन लाभ इसके लायक होंगे या नहीं। बेशक अगर स्मृति तंग है, यह एक आंतरिक लूप में है, या एक कार्यक्रम जिसे अक्सर कहा जाता है (जैसे एक बार एक सेकंड), जो संतुलन को बदलता है।

Answer 3

ध्यान में रखना एक और बात यह है कि फ़ाइल I/O हमेशा धीमा ऑपरेशन होने जा रहा है। ल्यूक टौराइल का समाधान सही है, लेकिन अन्य विकल्प भी हैं। पूरी फाइल को स्मृति में एक बार में पढ़ना अलग-अलग पढ़ने से बहुत तेज़ होगा।

Answer 4

ठीक है। मैं यह नहीं कह रहा हूं कि यह फ़ाइल

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

एनबी। यह उल्लेखनीय है कि std :: ifstream buffered है। यह फ़ाइल (डेटा अपेक्षाकृत बड़े) में डेटा से डेटा पढ़ता है। स्ट्रीम ऑपरेशन बफर के खिलाफ किया जाता है जब अधिक डेटा की आवश्यकता होती है तो केवल एक और पढ़ने के लिए फ़ाइल पर लौट आती है। तो स्मृति में सभी डेटा चूसने से पहले कृपया सत्यापित करें कि यह एक बोतल गर्दन है।

#include <fstream> 
#include <sstream> 
#include <vector> 

int main() 
{ 
    std::ifstream  file("Plop"); 
    if (file) 
    { 
     /* 
     * Get the size of the file 
     */ 
     file.seekg(0,std::ios::end); 
     std::streampos   length = file.tellg(); 
     file.seekg(0,std::ios::beg); 

     /* 
     * Use a vector as the buffer. 
     * It is exception safe and will be tidied up correctly. 
     * This constructor creates a buffer of the correct length. 
     * 
     * Then read the whole file into the buffer. 
     */ 
     std::vector<char>  buffer(length); 
     file.read(&buffer[0],length); 

     /* 
     * Create your string stream. 
     * Get the stringbuffer from the stream and set the vector as it source. 
     */ 
     std::stringstream  localStream; 
     localStream.rdbuf()->pubsetbuf(&buffer[0],length); 

     /* 
     * Note the buffer is NOT copied, if it goes out of scope 
     * the stream will be reading from released memory. 
     */ 
    } 
}