क्या सी ++ में मुद्रित वर्णों की संख्या प्राप्त करने का कोई आसान तरीका है?

Question

printf(...) कंसोल पर आउटपुट आउटपुट की संख्या देता है, जो मुझे कुछ प्रोग्रामों को डिजाइन करने में बहुत उपयोगी लगता है। तो, मैं सोच रहा था कि सी ++ में एक समान सुविधा है, क्योंकि cout < < एक ऑपरेटर है जो रिटर्न प्रकार के बिना है (कम से कम मैं इसे समझने से)।

Answer 1

आप वर्णों की गिनती के लिए अपना खुद का streambufcout जोड़ सकते हैं।

इस वर्ग कि यह सब लपेटता है:

class CCountChars { 
public: 
    CCountChars(ostream &s1) : m_s1(s1), m_buf(s1.rdbuf()), m_s1OrigBuf(s1.rdbuf(&m_buf)) {} 
    ~CCountChars() { m_s1.rdbuf(m_s1OrigBuf); m_s1 << endl << "output " << m_buf.GetCount() << " chars" << endl; } 

private: 
    CCountChars &operator =(CCountChars &rhs) = delete; 

    class CCountCharsBuf : public streambuf { 
    public: 
     CCountCharsBuf(streambuf* sb1) : m_sb1(sb1) {} 
     size_t GetCount() const { return m_count; } 

    protected: 
     virtual int_type overflow(int_type c) { 
      if (streambuf::traits_type::eq_int_type(c, streambuf::traits_type::eof())) 
       return c; 
      else { 
       ++m_count; 
       return m_sb1->sputc((streambuf::char_type)c); 
      } 
     } 
     virtual int sync() { 
      return m_sb1->pubsync(); 
     } 

     streambuf *m_sb1; 
     size_t m_count = 0; 
    }; 

    ostream &m_s1; 
    CCountCharsBuf m_buf; 
    streambuf * const m_s1OrigBuf; 
}; 

और तुम इस तरह इसका इस्तेमाल: वस्तु उदाहरण मौजूद है

{ 
    CCountChars c(cout); 
    cout << "bla" << 3 << endl; 
} 

हालांकि यह अदालत द्वारा सभी पात्रों उत्पादन गिना जाता है।

ध्यान रखें कि यह केवल cout के माध्यम से वर्ण आउटपुट की गणना करेगा, printf के साथ मुद्रित वर्ण नहीं।

Answer 2

आप एक फ़िल्टरिंग स्ट्रीम बफर बना सकते हैं जो लिखे गए अक्षरों की संख्या की रिपोर्ट करता है। उदाहरण के लिए:

class countbuf 
    : std::streambuf { 
    std::streambuf* sbuf; 
    std::streamsize size; 
public: 
    countbuf(std::streambuf* sbuf): sbuf(sbuf), size() {} 
    int overflow(int c) { 
     if (traits_type::eof() != c) { 
      ++this->size; 
     } 
     return this->sbuf.sputc(c); 
    } 
    int sync() { return this->sbuf->pubsync(); } 
    std::streamsize count() { this->size; } 
}; 

तुम सिर्फ इस धारा बफर एक फिल्टर के रूप का उपयोग करेंगे:

int main() { 
    countbuf sbuf; 
    std::streambuf* orig = std::cout.rdbuf(&sbuf); 
    std::cout << "hello: "; 
    std::cout << sbuf.count() << "\n"; 
    std::cout.rdbuf(orig); 
}