ऑपरेटर << - अंतिम तर्क का पता कैसे लगाएं

Question

मैं C++ में लॉग क्लास लिख रहा हूं। यह वर्ग एक सिंगलटन है। मैं इस तरह से लॉग जोड़ना चाहते हैं:

Log::GetInstance() << "Error: " << err_code << ", in class foo"; 

ठीक है, और एक लॉग ऑब्जेक्ट के अंदर, मैं समय पर इस पूरे लाइन को बचाने के लिए जब अंतिम तर्क इस उदाहरण में आता है (", वर्ग foo में" चाहते हैं)।

अंतिम एक < < तर्क का पता कैसे लगाएं? < < एक < < ख < < < is_this_last < maybe_this_is < < or_not।

मुझे किसी भी अंत टैग का उपयोग नहीं करना है।

Answer 1

आप सिंगलटन का उपयोग न करके इस समस्या को हल कर सकते हैं। आप इस तरह से एक समारोह करते हैं:

Log log() 
{ 
    return Log(); 
} 

आप एक लॉग लगभग उसी तरह तुमने जोड़ सकते हैं इससे पहले कि:

log() << "Error: " << err_code << ", in class foo"; 

अंतर यह है कि है Log वस्तु का नाशक इस लाइन के बाद कहा जाता हो जाता है । तो अब आपके पास यह पता लगाने का एक तरीका है कि अंतिम तर्क संसाधित होने पर।

Answer 2

मैं आपके Log::GetInstance लॉग ऑब्जेक्ट के बजाय प्रॉक्सी ऑब्जेक्ट वापस कर दूंगा। प्रॉक्सी ऑब्जेक्ट उस डेटा को सहेज लेगा जो इसे लिखा गया है, और उसके बाद इसके विनाशक में, यह वास्तव में लॉग में संचित डेटा लिख ​​देगा।

Answer 3

अपने ऑपरेटरों के साथ बहुत चालाक न हों। जब आप ऐसा करने के लिए समझ में आता है तो आपको ऑपरेटरों को ओवरलोड करना चाहिए। यहां आपको नहीं करना चाहिए। यह अजीब लग रहा है।

Log::Message(message_here); 

जो एक std :: स्ट्रिंग लेता है:

तुम सिर्फ एक स्थिर विधि है कि इस तरह दिखता है होना चाहिए। फिर ग्राहकों को त्रुटि स्ट्रिंग को इकट्ठा करने के बारे में पता लगाने का सिर दर्द होता है।

Answer 4

ऑपरेटर < < के बाद आप लॉग को एक अलग ऑब्जेक्ट करते हैं।

template<typename T> 
LogFindT operator<<(Log aLog, T const& data) 
{ 
    // Put stuff in log. 
    log.putStuffInLog(data); 

    // now return the object to detect the end of the statement. 
    return LogFindT(aLog); 
} 


struct LogFindT 
{ 
    LogFindT(Log& aLog) : TheLog(aLog) {} 
    Log& TheLog; 
    ~LogFindT() 
    { 
     // Do stuff when this object is eventually destroyed 
     // at the end of the expression. 
    } 
}; 

template<typename T> 
LogFindT& operator<<(LogFindT& aLog, T const& data) 
{ 
    aLog.TheLog.putStuffInLog(data); 

    // Return a reference to the input so we can chain. 
    // The object is thus not destroyed until the end of the stream. 
    return aLog; 
} 

Answer 5

मुझे लगता है कि जैरी और मार्टिन सबसे अच्छा सुझाव दे दिया है, लेकिन पूर्णता के लिए के लिए, पहली बात मैं के बारे में सोचा std::endl था।

आप एक कस्टम streambuf वर्ग द्वारा iostream प्रणाली के भीतर Log लागू किया है, तो आप बस पंक्ति के अंत में << endl या << flush जोड़ सकते हैं। चूंकि आप पूछ रहे हैं, मुझे लगता है कि आपने नहीं किया।

लेकिन आप endl कामों की नकल कर सकते हैं।या तो एक जोड़तोड़ हैंडलर

Log &operator<< (Log &l, Log & (*manip)(Log &)) 
    { return manip(l); } // generically call any manipulator 

Log &flog(Log &l) // define a manipulator "flush log" 
    { l->flush(); return l; } 

जोड़ सकते हैं या एक समर्पित operator<<

struct Flog {} flog; 

Log &operator<< (Log &l, Flog) 
    { l->flush(); return l; } 

Answer 6

वहाँ आप क्या चाहते हैं करने के लिए कोई अच्छा तरीका है जोड़ें। सी और सी ++ लाइन-उन्मुख भाषाओं नहीं हैं। "कोड की रेखा" या कुछ भी जैसी कोई बड़ी इकाई नहीं है, न ही किसी भी तरह से जंजीर कॉल संयुक्त हैं।

C++ में अभिव्यक्ति "एक < < ख < < ग < < घ" वास्तव में ऑपरेटर < < को तीन अलग-अलग कॉल के बराबर है, इस तरह:

t1 = a; 
t2 = t1.operator<<(b); 
t3 = t2.operator<<(c); 
t4 = t3.operator<<(d); 

क्यों सी ++ ostreams उपयोग endl है कि एक के रूप में स्पष्ट अंत-रेखा मार्कर; अन्यथा ऐसा करने का कोई अच्छा तरीका नहीं है।