फ़ाइल * और आईट्रीम: दो कनेक्ट करें?

Question

मान लीजिए कि मैं निष्पादन योग्य "पॉपन" करता हूं, मुझे बदले में FILE* मिलता है। इसके अलावा, मान लीजिए कि मैं इस फ़ाइल को istream ऑब्जेक्ट को आसान प्रसंस्करण के लिए "कनेक्ट" करना चाहता हूं, क्या ऐसा करने का कोई तरीका है?

Answer 1

कोई मानक तरीका नहीं है लेकिन यदि आप त्वरित समाधान चाहते हैं तो आप fileno() के साथ फाइल डिस्क्रिप्टर प्राप्त कर सकते हैं और फिर जोसुटिस 'fdstream का उपयोग कर सकते हैं। आसपास के समान प्रयास हो सकते हैं लेकिन मैंने इसे दूर के अतीत में उपयोग किया और यह ठीक काम किया। यदि कुछ और नहीं है तो यह स्वयं को लागू करने के लिए एक बहुत अच्छा मानचित्र होना चाहिए।

Answer 2

निश्चित रूप से एक तरीका है, अपना istream लागू करें जिसे FILE* से बनाया जा सकता है।

यदि आप पूछ रहे हैं कि ऐसा करने का कोई मानक तरीका है, तो नहीं।

Answer 3

आप std :: basic_streambuf या std :: streambuf कक्षाओं को प्राप्त करके दूर हो सकते हैं।
इन पंक्तियों के साथ कुछ:

#include <stdio.h> 
#include <iostream> 

#define BUFFER_SIZE  1024 

class popen_streambuf : public std::streambuf { 
public: 
    popen_streambuf() : fp(NULL) { 
    } 
    ~popen_streambuf() { 
     close(); 
    } 
    popen_streambuf *open(const char *command, const char *mode) { 
     fp = popen(command, mode); 
     if (fp == NULL) 
      return NULL; 
     buffer = new char_type[BUFFER_SIZE]; 
     // It's good to check because exceptions can be disabled 
     if (buffer == NULL) { 
      close(); 
      return NULL; 
     } 
     setg(buffer, buffer, buffer); 
     return this; 
    } 
    void close() { 
     if (fp != NULL) { 
      pclose(fp); 
      fp = NULL; 
     } 
    } 
    std::streamsize xsgetn(char_type *ptr, std::streamsize n) { 
     std::streamsize got = showmanyc(); 
     if (n <= got) { 
      memcpy(ptr, gptr(), n * sizeof(char_type)); 
      gbump(n); 
      return n; 
     } 
     memcpy(ptr, gptr(), got * sizeof(char_type)); 
     gbump(got); 

     if (traits_type::eof() == underflow()) { 
      return got; 
     } 
     return (got + xsgetn(ptr + got, n - got)); 
    } 
    int_type underflow() { 
     if (gptr() == 0) { 
      return traits_type::eof(); 
     } 
     if (gptr() < egptr()) { 
      return traits_type::to_int_type(*gptr()); 
     } 
     size_t len = fread(eback(), sizeof(char_type), BUFFER_SIZE, fp); 
     setg(eback(), eback(), eback() + (sizeof(char_type) * len)); 
     if (0 == len) { 
      return traits_type::eof(); 
     } 
     return traits_type::to_int_type(*gptr()); 
    } 
    std::streamsize showmanyc() { 
     if (gptr() == 0) { 
      return 0; 
     } 
     if (gptr() < egptr()) { 
      return egptr() - gptr(); 
     } 
     return 0; 
    } 
private: 
    FILE *fp; 
    char_type *buffer; 
}; 

int main(int argc, char *argv) 
{ 
    char c; 
    popen_streambuf sb; 
    std::istream is(&sb); 

    if (NULL == sb.open("ls -la", "r")) { 
     return 1; 
    } 

    while (is.read(&c, 1)) { 
     std::cout << c; 
    } 

    return 0; 
}