toán tử << - cách phát hiện đối số cuối cùng

Question

Tôi đang viết một lớp bản ghi trong C++. Lớp này là một singleton. Tôi muốn thêm các bản ghi theo cách như vậy:

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

Ok, và bên trong một đối tượng Log, tôi muốn lưu toàn bộ dòng này vào thời điểm đó khi tranh luận cuối cùng đến ("trong lớp foo" trong ví dụ này).

Cách phát hiện đối số cuối cùng < <? a < < b < < is_this_last < < maybe_this_is < < or_not.

Tôi không sử dụng bất kỳ thẻ kết thúc nào.

Answer 1

Bạn có thể giải quyết vấn đề này bằng cách không sử dụng singleton. Nếu bạn thực hiện một chức năng như thế này:

Log log() 
{ 
    return Log(); 
} 

Bạn có thể thêm một khúc gỗ gần giống như cách bạn đã làm trước đó:

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

Sự khác biệt được rằng destructor của đối tượng Log được gọi sau khi dòng này . Vì vậy, bây giờ bạn có một cách để phát hiện khi đối số cuối cùng đã được xử lý.

Answer 2

Tôi sẽ trả lại đối tượng proxy thay vì đối tượng nhật ký. Đối tượng proxy sẽ lưu dữ liệu được ghi vào nó, và sau đó trong destructor của nó, nó sẽ thực sự ghi dữ liệu được tích lũy vào nhật ký.

Answer 3

Đừng quá thông minh với nhà điều hành của bạn. Bạn nên quá tải các nhà khai thác khi nó làm cho tinh thần để làm như vậy. Ở đây bạn không nên. Điều đó có vẻ lạ.

Bạn chỉ cần có một phương pháp tĩnh trông như thế này:

Log::Message(message_here); 

mà phải mất một std :: string. Sau đó, khách hàng có đầu-ache của figuring ra làm thế nào để lắp ráp các chuỗi lỗi.

Answer 4

Bạn đặt nhật ký trả về một đối tượng khác sau toán tử < <.

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

Tôi nghĩ rằng Jerry và Martin đã đưa ra những gợi ý tốt nhất, nhưng vì lợi ích của sự hoàn chỉnh, điều đầu tiên tôi nghĩ đến là std::endl.

Nếu bạn thực hiện Log trong hệ thống iostream bởi một lớp tùy chỉnh streambuf, sau đó bạn chỉ có thể thêm << endl hoặc << flush vào cuối dòng. Vì bạn đang hỏi, tôi cho rằng bạn đã không làm vậy.

Nhưng bạn có thể bắt chước cách hoạt động của endl.Hoặc là thêm một handler thao túng

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; } 

hoặc thêm một chuyên operator<<

struct Flog {} flog; 

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

Answer 6

Không có cách nào tốt để làm những gì bạn muốn. C và C++ đơn giản không phải là ngôn ngữ hướng dòng. Không có đơn vị lớn hơn như một "dòng mã" hoặc bất cứ điều gì, cũng không phải là chuỗi cuộc gọi kết hợp trong bất kỳ cách nào.

Trong C++ khái niệm "một < < b < < c < < d" là chính xác tương đương với ba cuộc gọi riêng biệt để điều hành < <, như thế này:

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

Đó là lý do tại sao C++ ostreams sử dụng endl như một dấu đầu dòng rõ ràng; không có cách nào tốt để làm điều đó bằng cách khác.