Enregistrement des erreurs dans les macros du préprocesseur C ++ __LINE__, __FUNCTION__
-
05-07-2019 - |
Question
J'essaie d'incorporer une simple erreur de connexion dans mon application existante. Au moment où elle signale des erreurs en utilisant simplement cout
, j'espérais conserver une interface similaire à l'aide de l'opérateur <<
. Cependant, je souhaite qu’il enregistre la ligne et que l’erreur s’est produite, mais je ne souhaite pas avoir à taper __LINE__, __FUNCTION__
à chaque fois que j’ai besoin de me connecter. Est-ce que quelqu'un connaît une astuce que je peux utiliser pour permettre à la macro __LINE__
d'être utilisée dans une autre fonction, indiquant plutôt la ligne d'appel? J'espère que cela a du sens.
class myLogClass {
uint8_t level;
public:
bool operator<<( const char * input );
};
bool myLogClass::operator<<( const char * input ) {
logItInSQL( input );
return true;
}
Au lieu de cela à chaque fois
myLogClass << "Line No: " << __LINE__
<< " Function: " << __FUNCTION__
<< " Error: " << "This is my error to be logged";
Je voudrais juste pouvoir faire:
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;
}
La solution
myLogClass << "Line No: " << __LINE__ ...
Avec votre operator <<
chaînage ne fonctionnera pas car il renvoie un bool
.
bool myLogClass::operator << (const char * input)
Il est habituel de définir l'insertion de flux comme suit:
std::ostream& myLogClass::operator << (std::ostream& o, const char * input) {
// do something
return o;
}
Faites ceci:
#define log(o, s) o << "Line No: " << __LINE__ << \
" Function: " << __FUNCTION__ << \
" Error: " << s // note I leave ; out
De plus, vous pouvez envelopper la macro dans une do-while
boucle:
#define log(o, s) do { o << "Line No: " << __LINE__ << \
" Function: " << __FUNCTION__ << \
" Error: " << s; \
} while(0) // here, I leave ; out
Ensuite, vous pouvez écrire avec joie:
myLogClass myLogger; // do this
// use it
log(myLogger, "This is my error to be logged"); // note the ;
Autres conseils
Dans ANSI C (qui devrait également fonctionner en C ++, je suppose), vous pouvez le faire à l’aide de fonctions variadiques et de macros de préprocesseur. Voir l'exemple ci-dessous:
#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;
}
Non, c’est pourquoi la journalisation est effectuée avec des macros. __LINE__
doit être développé par le préprocesseur sur la ligne en question et non par une fonction de journalisation commune.
Comme Adam Mitz l'a mentionné, vous devez utiliser __LINE__ à la place de la visite.
Je vous recommande d’ajouter un paramètre supplémentaire tel que & "AdditionalInfo &"; et créez une macro qui générera ce ". additionalInfo " en utilisant __LINE__ et __FUNCTION __.
Je n'ai pas pu obtenir le code lors de la première réponse à compiler. J'utilise cette simple macro qui accomplit bien la tâche:
#define qlog(s) std::cerr << __FUNCTION__ << "::" << __LINE__ << "\t" << s << endl