Fehlerprotokollierung C ++ Präprozessormakros __LINE__, __FUNCTION__

Question

ich versuche, einen einfachen Fehler zu integrieren in meine bestehenden App angemeldet hat, im Moment ist es Fehler nur mit cout berichtet, so wurde ich eine ähnliche Schnittstelle mit dem << Bediener zu halten hoffen. Aber ich will es die Linie protokollieren und Funktion der Fehler aufgetreten ist, aber ich will nicht zu haben, jedes Mal wenn ich anmelden muß Typen __LINE__, __FUNCTION__. Kennt jemand einen Trick, den ich verwenden kann das __LINE__ Makro zu ermöglichen, in einer anderen Funktion, die Berichterstattung über die Rufleitung stattdessen verwendet werden sollte? Hoffe, das macht Sinn.

class myLogClass {
    uint8_t level;                  
public:                 
    bool operator<<( const char * input );          
};

bool myLogClass::operator<<( const char * input ) {
    logItInSQL( input );
    return true;
}

Statt dem jedes Mal

myLogClass << "Line No: " << __LINE__
    << " Function: " << __FUNCTION__
    << " Error: " << "This is my error to be logged";

Ich möchte nur in der Lage sein zu tun:

myLogClass << "This is my error to be logged";

bool myLogClass::operator<<( const char * input ) {
    logItInSQL( " Line No: __LINE__" );
    logItInSQL( " Function: __FUNCTION__" );
    logItInSQL( " Error: " + input );
    return true;
}

Answer 1

myLogClass << "Line No: " << __LINE__ ...

Mit Ihrer operator << Chaining wird nicht funktionieren, da es eine bool zurückgibt.

bool myLogClass::operator << (const char * input)

Es ist üblich Strom Einsetzen wie folgt zu definieren:

std::ostream& myLogClass::operator << (std::ostream& o, const char * input) {
    // do something
    return o;
}

Tun Sie dies:

#define log(o, s) o << "Line No: " << __LINE__ << \
                   " Function: " << __FUNCTION__ << \
                   " Error: " << s // note I leave ; out

Darüber hinaus können Sie das Makro in einer do-while Schleife wickeln:

#define log(o, s) do { o << "Line No: " << __LINE__ << \
                   " Function: " << __FUNCTION__ << \
                   " Error: " << s; \ 
                  } while(0) // here, I leave ; out

Dann können Sie gerne schreiben:

 myLogClass myLogger; // do this

 // use it
log(myLogger, "This is my error to be logged"); // note the ;

Answer 2

In ANSI C (die auch in C ++ arbeiten sollte Ich gehe davon aus), können Sie tun, dass variadische Funktionen und Präprozessormakros verwenden. Siehe Beispiel unten:

#include <stdio.h>
#include <stdarg.h>

#define MAXMSIZE 256
#define MyDebug(...) MyInternalDebug(__FILE__,__FUNCTION__,__LINE__,__VA_ARGS__)

void MyInternalDebug( char *file, char *function, const int line, const char *format, ... )
{
    char message[MAXMSIZE];
    // Variable argument list (VA)
    va_list ap;
    // Initialize VA
    // args : Name of the last named parameter in the function definition.
    // The arguments extracted by subsequent calls to va_arg are those after 'args'.
    va_start(ap, format);

    // Composes a string with the same text that would be printed if 'format' was used on printf,
    // but using the elements in the variable argument list identified by 'ap' instead of
    // additional function arguments and storing the resulting content as a C string in the buffer pointed by 'message'.
    // * The state of arg is likely to be altered by the call.
    vsprintf(message, format, ap);
    // Custom print function
    printf("%s\t%s\t%d\t%s\n",file, function, line, message);

    // Finzalize use of VA
    va_end(ap);
}

int main ()
{  
    MyInternalDebug(__FILE__, __FUNCTION__, __LINE__, "An error occured with message = '%s'", "Stack Overflow");
    MyDebug("Another error occured with code = %d", 666);

    return 0;
}

Answer 3

Nein, das ist, warum die Protokollierung mit Makros erfolgt. __LINE__ muss durch den Präprozessor auf der Linie in Frage erweitert werden, nicht in einer gemeinsamen Protokollfunktion.

Answer 4

Als Adam Mitz erwähnten Sie brauchen __LINE__ an der Stelle des Aufrufs zu verwenden.
Wir empfehlen Ihnen einen zusätzlichen Parameter wie „additionalInfo“ hinzuzufügen und ein Makro erstellen, um diesen „additionalInfo“ __LINE__ und __FUNCTION mit generiert __.

Answer 5

Ich konnte nicht den Code in der ersten Antwort zu kompilieren. Ich benutze diese einfache Makro, die die Aufgabe erfüllt auch:

#define qlog(s) std::cerr << __FUNCTION__ << "::" << __LINE__ << "\t" << s << endl