Verallgemeinerte Log-Datei in C++

Question

Ich versuche, eine Protokolldatei in C++ zu erstellen ... Kann jemand sagen, wie mehrere Variablen wie eine Zeichenfolge, Integer in die Datei geschrieben werden ... die in den Datei-Teil des Codes schreiben in einer anderen Funktion in einer anderen Datei geschrieben (ex log_file.h.) mit der Hauptdatei verknüpft ..

Beispiel:

for(int i=0;i<3;i++) 
{....} 

ich jede Iteration Wert von i in die Protokolldatei schreiben möchten ... Ich kann dies tun, indem Sie "value of i" -> in einer Zeichenfolge und "i" -> als Ganzzahl übergeben ... aber das wird nicht für alle Funktionen funktionieren ..

Answer 1

Ich bekomme Ihr Problem nicht. Für eine Protokolldatei könnten Sie etwas Ähnliches wie das folgende verwenden:

Bitte spezifizieren Sie Ihr Problem.

Answer 2

Sie können die Log-Methode so etwas wie dieses definieren

void Log(uint16_t level, const char * format, ...) 

mit va_list Sie Ihre Log-

char buffer[4096] = { 0 }; 
va_list argList; 
va_start(argList, format); 
vsprintf(buffer, format, argList); 
va_end(argList); 

jetzt buffer hält die formatierte Protokollmeldung formatiert werden können, können Sie buffer verwenden, um in ein schreiben Datei, drucken zu Konsole usw.

Verwendung

for(int i=0; i<10; i++) 
    Log(1, "%d iteration = %s", i, "hello"); 

in Sie puffern Sie

0 iteration hello 
1 iteration hello 
.... 
9 iteration hello 

Verwenden Ebene erhalten die Art der Protokollmeldung

Answer 3

Sie printf wie Funktion implementieren kann zu identifizieren, die die Parameter in eine Protokolldatei variable argument list mit log wird.

#include <stdarg.h>  /* va_list, va_start, va_arg, va_end */ 

void logger(const char *_pcFormat, ...) 
{ 
    char cszFilePath[] = "/var/tmp/mylog.txt"; 


    //assuming each log line will be less than equal to 2048 bytes. 
    char cszLine[2048] = {0}; 

    //optional: you can even log the time, uncomment the following 2 lines, if required 
    //time_t ulTime = time(NULL); 
    //snprintf(cszLine, sizeof(cszLine), "%02d:%02d:%02d ", stTime.tm_hour, stTime.tm_min, stTime.tm_sec); 

    va_list aptr; 
    va_start(aptr, _pcFormat); 
    char *pcLine = cszLine; 
    vsprintf(pcLine + strlen(cszLine), _pcFormat, aptr); 
    va_end(aptr); 

    FILE *fp = fopen(cszFilePath, "a+"); 
    if(fp == NULL) 
    { 
      return; 
    } 

    fprintf(fp, "%s\n", cszLine); 

    fclose(fp); 
    fp = NULL; 
} 

update_1: In dieser Version wird es von der Länge der Linie keine anfängliche Annahme.

Answer 4

Wenn Sie es auf eine C++ Weise tun möchten, dann denke ich, dass Sie Streams und Vorlagen verwenden sollten. Wie folgt aus:

#include <iostream> 
#include <fstream> 
#include <stdexcept> 

class Logger 
{ 
public: 
    // Logger cannot exist without file. 
    Logger() = delete; 

    // Disable copy constructor since std::ofstream is not copyable. 
    Logger(Logger const&) = delete; 

    // Constructor 
    explicit Logger(std::string const& f_path) 
     : log_file { f_path } 
    { 
     if (!log_file.is_open()) 
     { 
      throw std::runtime_error("Unable to open log file"); 
     } 
    } 

    // Disable copy. 
    Logger& operator=(Logger const&) = delete; 

    // Cleanup. 
    ~Logger() 
    { 
     log_file.close(); 
    } 

    // Write a single value into log file stream. 
    template<typename T> 
    void write(T const& v) 
    { 
     log_file << v; 
    } 

    // Write multiple values. 
    template<typename Arg, typename ...Args> 
    void write(Arg const& arg, Args const&... args) 
    { 
     // here we write the first value of the values list. 
     write(arg); 
     // here we recursively pass the rest values to the function. 
     write(args...); 
    } 
private: 
    // Log file stream. 
    std::ofstream log_file; 
}; 

int main(int argc, char* argv[]) 
{ 
    Logger l { "test.log" }; 
    l.write(1); 
    l.write("qwe", 34); 
    return 0; 
} 

Wie Sie sehen der Logger auf std::ofstream abhängt. Wenn Sie also einen nicht unterstützten Typ protokollieren müssen, müssen Sie nur eine Überladung dafür erstellen. So:

// A custom type 
struct MyType 
{ 
    int id; 
    std::string name; 

    // an overload 
    friend std::ofstream& operator<<(std::ofstream& ofs, MyType const& v) 
    { 
     ofs << "(" << v.id << ":" << v.name <<")"; 
    } 
}; 

Und dann verwenden Sie es in main:

MyType person { 23, "John" }; 
l.write(person);