C # define makro for debug printing

Używam czegoś takiego:

#ifdef DEBUG
 #define D if(1) 
#else
 #define D if(0) 
#endif

Niż używam D jako prefiksu:

D printf("x=%0.3f\n",x);

Kompilator widzi kod debugowania, nie ma problemu z przecinkami i działa wszędzie. Działa również, gdy printf nie wystarczy, powiedzmy, kiedy musisz zrzucić tablicę lub obliczyć jakąś wartość diagnozującą, która jest zbędna dla samego programu.

EDIT: Ok, to może generować problem, gdy jest else gdzieś w pobliżu, które mogą być przechwycone przez ten wstrzykiwany if. Jest to wersja, która przechodzi it:

#ifdef DEBUG
 #define D 
#else
 #define D for(;0;)
#endif

Dla implementacji przenośnej (ISO C90), można użyć podwójnego nawiasu, jak to;

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

#ifndef NDEBUG
#  define debug_print(msg) stderr_printf msg
#else
#  define debug_print(msg) (void)0
#endif

void
stderr_printf(const char *fmt, ...)
{
  va_list ap;
  va_start(ap, fmt);
  vfprintf(stderr, fmt, ap);
  va_end(ap);
}

int
main(int argc, char *argv[])
{
  debug_print(("argv[0] is %s, argc is %d\n", argv[0], argc));
  return 0;
}

Or (hackish, wouldn ' t recommend it)

#include <stdio.h>

#define _ ,
#ifndef NDEBUG
#  define debug_print(msg) fprintf(stderr, msg)
#else
#  define debug_print(msg) (void)0
#endif

int
main(int argc, char *argv[])
{
  debug_print("argv[0] is %s, argc is %d"_ argv[0] _ argc);
  return 0;
}

Zrobiłbym coś takiego

#ifdef DEBUG
#define debug_print(fmt, ...) fprintf(stderr, fmt, __VA_ARGS__)
#else
#define debug_print(fmt, ...) do {} while (0)
#endif

Oto wersja, której używam:

#ifdef NDEBUG
#define Dprintf(FORMAT, ...) ((void)0)
#define Dputs(MSG) ((void)0)
#else
#define Dprintf(FORMAT, ...) \
    fprintf(stderr, "%s() in %s, line %i: " FORMAT "\n", \
        __func__, __FILE__, __LINE__, __VA_ARGS__)
#define Dputs(MSG) Dprintf("%s", MSG)
#endif

#define debug_print(FMT, ARGS...) do { \
    if (DEBUG) \
        fprintf(stderr, "%s:%d " FMT "\n", __FUNCTION__, __LINE__, ## ARGS); \
    } while (0)

Zgodnie z http://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html , przed __VA_ARGS__ powinno być ##.

W przeciwnym razie makro #define dbg_print(format, ...) printf(format, __VA_ARGS__) nie skompiluje następującego przykładu: dbg_print("hello world");.

Tego używam:

#if DBG
#include <stdio.h>
#define DBGPRINT printf
#else
#define DBGPRINT(...) /**/  
#endif

Ma przyjemną zaletę, aby prawidłowo obsługiwać printf, nawet bez dodatkowych argumentów. W przypadku DBG = = 0, nawet najgłupszy kompilator nie dostaje nic do żucia, więc żaden kod nie jest generowany.

Moim ulubionym z poniższych jest var_dump, który po wywołaniu jako:

var_dump("%d", count);

Generuje wyjście jak:

patch.c:150:main(): count = 0

Kod

#define DEBUG 1
#include <stdarg.h>
#include <stdio.h>
void debug_vprintf(const char *fmt, ...)
{
    va_list args;
    va_start(args, fmt);
    vfprintf(stderr, fmt, args);
    va_end(args);
}

/* Call as: (DOUBLE PARENTHESES ARE MANDATORY) */
/* var_debug(("outfd = %d, somefailed = %d\n", outfd, somefailed)); */
#define var_debug(x) do { if (DEBUG) { debug_vprintf ("%s:%d:%s(): ", \
    __FILE__,  __LINE__, __func__); debug_vprintf x; }} while (0)

/* var_dump("%s" variable_name); */
#define var_dump(fmt, var) do { if (DEBUG) { debug_vprintf ("%s:%d:%s(): ", \
    __FILE__,  __LINE__, __func__); debug_vprintf ("%s = " fmt, #var, var); }} while (0)

#define DEBUG_HERE do { if (DEBUG) { debug_vprintf ("%s:%d:%s(): HERE\n", \
    __FILE__,  __LINE__, __func__); }} while (0)

Dusiłem się nad tym, jak to zrobić od lat, a niedawno wymyśliłem to rozwiązanie, zanim zobaczyłem to pytanie. Po pierwsze, przy różnicy z odpowiedzią Lefflera , nie widzę jego argumentu, że wydruki debugowe powinny być zawsze kompilowane. Tak, kończy się drukiem debugowania, który nie kompiluje się czasami, ale nie jest tak trudno skompilować i przetestować je przed finalizacją projektu. Powiedzmy, że nie. najgorsze, co się dzieje, to to, że musisz poprawić kilka garści na duży projekt. Jeśli twój projekt nie jest HUUUUGE, to łatwiejsze niż to.

Moje rozwiązanie przewiduje poziomy szczegółowości debugowania; i jeśli ustawisz go na najwyższy poziom, Wszystkie się skompilują. Jeśli ostatnio używasz wysokiego poziomu szczegółowości debugowania, prawdopodobnie wszystkie już się skompilowały. Nigdy nie potrzebowałem więcej niż trzech poziomów, ale Jonathan mówi, że użył dziewięciu. Jego metoda również może mieć poziomy szczegółowości drukowania debugowania. Mój może być łatwo rozszerzony do obsługi dowolnej liczby poziomów, a jego może obsługa dowolnej liczby poziomów. Korzystanie z mojej metody może być prostsze; wymaga tylko dwóch instrukcji, gdy są używane w Twoim kodzie (chociaż ja również używam trzeciej).

W stosunku do kosztów dodatkowym etapem testowania ich, aby zobaczyć, że będą kompilowane przed dostawą, jest to, że

1. musisz im zaufać, aby zostali zoptymalizowani, Co Co prawda powinno się zdarzyć, jeśli masz wystarczający poziom optymalizacji.
2. ponadto, prawdopodobnie nie będzie, jeśli wydanie skompilować z optymalizacja wyłączona dla celów testowych (co jest co prawda rzadkie); i prawie na pewno nie będzie w ogóle podczas debugowania-w ten sposób wykonując dziesiątki lub setki poleceń" if (DEBUG) " w czasie wykonywania; w ten sposób spowalniając wykonywanie (co jest moim sprzeciwem) i mniej ważne, zwiększając rozmiar pliku wykonywalnego lub dll; a tym samym czas wykonywania i kompilacji. Jonathan jednak informuje mnie, że jego metoda może być wykonana, aby w ogóle nie kompilować oświadczeń.

Więc to, czego chciałem, to makro debugowania, które nie kompiluje się, jeśli nie ma być wydrukowane, ale robi, jeśli jest. Chciałem również poziomy debugowania, tak aby np. jeśli chciałem wydajność-kluczowe części kodu nie do drukowania w niektórych momentach, ale do drukowania w innych, mógłbym ustawić poziom debugowania i mieć dodatkowe wydruki debugowania kopać. Natknąłem się na sposób implementacji poziomów debugowania, które określały, czy druk był w ogóle skompilowany, czy nie. Osiągnąłem to w ten sposób:

DebugLog.h:

// FILE: DebugLog.h
// REMARKS: This is a generic pair of files useful for debugging.  It provides three levels of 
// debug logging, currently; in addition to disabling it.  Level 3 is the most information.
// Levels 2 and 1 have progressively more.  Thus, you can write: 
//     DEBUGLOG_LOG(1, "a number=%d", 7);
// and it will be seen if DEBUG is anything other than undefined or zero.  If you write
//     DEBUGLOG_LOG(3, "another number=%d", 15);
// it will only be seen if DEBUG is 3.  When not being displayed, these routines compile
// to NOTHING.  I reject the argument that debug code needs to always be compiled so as to 
// keep it current.  I would rather have a leaner and faster app, and just not be lazy, and 
// maintain debugs as needed.  I don't know if this works with the C preprocessor or not, 
// but the rest of the code is fully C compliant also if it is.

#define DEBUG 1

#ifdef DEBUG
#define DEBUGLOG_INIT(filename) debuglog_init(filename)
#else
#define debuglog_init(...)
#endif

#ifdef DEBUG
#define DEBUGLOG_CLOSE debuglog_close
#else
#define debuglog_close(...)
#endif

#define DEBUGLOG_LOG(level, fmt, ...) DEBUGLOG_LOG ## level (fmt, ##__VA_ARGS__)

#if DEBUG == 0
#define DEBUGLOG_LOG0(...)
#endif

#if DEBUG >= 1
#define DEBUGLOG_LOG1(fmt, ...) debuglog_log (fmt, ##__VA_ARGS__)
#else
#define DEBUGLOG_LOG1(...)
#endif

#if DEBUG >= 2
#define DEBUGLOG_LOG2(fmt, ...) debuglog_log (fmt, ##__VA_ARGS__)
#else
#define DEBUGLOG_LOG2(...)
#endif

#if DEBUG == 3
#define DEBUGLOG_LOG3(fmt, ...) debuglog_log (fmt, ##__VA_ARGS__)
#else
#define DEBUGLOG_LOG3(...)
#endif

void debuglog_init(char *filename);
void debuglog_close(void);
void debuglog_log(char* format, ...);

DebugLog.cpp:

// FILE: DebugLog.h
// REMARKS: This is a generic pair of files useful for debugging.  It provides three levels of 
// debug logging, currently; in addition to disabling it.  See DebugLog.h's remarks for more 
// info.

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

#include "DebugLog.h"

FILE *hndl;
char *savedFilename;

void debuglog_init(char *filename)
{
    savedFilename = filename;
    hndl = fopen(savedFilename, "wt");
    fclose(hndl);
}

void debuglog_close(void)
{
    //fclose(hndl);
}

void debuglog_log(char* format, ...)
{
    hndl = fopen(savedFilename,"at");
    va_list argptr;
    va_start(argptr, format);
    vfprintf(hndl, format, argptr);
    va_end(argptr);
    fputc('\n',hndl);
    fclose(hndl);
}

Używanie makr

Aby go użyć, po prostu zrób:

DEBUGLOG_INIT("afile.log");

Aby zapisać do pliku dziennika, po prostu wykonaj:

DEBUGLOG_LOG(1, "the value is: %d", anint);

Aby zamknąć, robisz:

DEBUGLOG_CLOSE();

Chociaż obecnie nie jest to nawet konieczne, technicznie rzecz biorąc, ponieważ nic nie robi. Nadal używam teraz CLOSE, jednak na wypadek, gdybym zmienił zdanie na temat tego, jak to działa i chciał pozostawić plik otwarty między instrukcjami logowania.

Następnie, gdy chcesz włączyć drukowanie debugowania, po prostu edytuj pierwsze # define w pliku nagłówkowym, aby powiedzieć, np.

#define DEBUG 1

Aby instrukcje logowania skompilowały się do niczego, wykonaj

#define DEBUG 0

Jeśli potrzebujesz informacji z często wykonywanego fragmentu kodu (tj. o wysokim poziomie szczegółowości) możesz chcieć napisać:

 DEBUGLOG_LOG(3, "the value is: %d", anint);

Jeśli zdefiniujesz debugowanie jako 3, rejestrowanie poziomów 1, 2 i 3 skompiluje się. Jeśli ustawisz go na 2, otrzymasz poziomy logowania 1 i 2. Jeśli ustawisz ją na 1, otrzymasz tylko instrukcje logowania poziomu 1.

Jeśli chodzi o pętlę do-while, ponieważ jest to ewaluacja pojedynczej funkcji lub nic, zamiast instrukcji if, pętla nie jest potrzebna. Ok, wykastruj mnie za używanie C zamiast C++ IO (i Qt QString:: arg() jest bezpieczniejszym sposobem formatowania zmiennych również w Qt - jest to dość sprytne, ale zajmuje więcej kodu, a dokumentacja formatowania nie jest tak zorganizowana, jak może być - ale nadal znalazłem przypadki, w których jest to preferowane), ale możesz umieścić dowolny kod w .plik cpp, który chcesz. Może to być również klasa, ale wtedy będziesz musiał utworzyć instancję i nadążyć za nią, lub zrobić nową () i zapisać ją. W ten sposób po prostu upuszczasz do źródła instrukcje #include, init i opcjonalnie close, i jesteś gotowy, aby rozpocząć korzystanie z niego. To byłaby dobra Klasa, jednak, jeśli jesteś tak skłonny.

Widziałem wcześniej wiele rozwiązań, ale żadne nie odpowiadało moim kryteriom tak dobrze, jak to.

1. można go rozszerzyć, aby zrobić tyle poziomów, ile chcesz.
2. kompiluje się do niczego, jeśli nie drukuje.
3. centralizuje IO w jednym łatwym do edycji miejscu.
4. jest elastyczny, używając formatowania printf.

Dodatkowo,

1. wymaga brak hackowania do wydruku bez argumentów (np. ERRLOG_LOG(3, "got here!");); dzięki temu korzystanie z np. Qt jest bezpieczniejsze .formatowanie arg (). Działa na MSVC, a więc prawdopodobnie gcc. Używa ## w #define s, co jest niestandardowe, jak wskazuje Leffler, ale jest szeroko wspierane. (Możesz go przekodować, aby nie używać ##, jeśli to konieczne, ale będziesz musiał użyć hacka, takiego jak on zapewnia.)

Warning: If you forget to provide the logging level argument, MSVC unhelpfully claims the identifier is not zdefiniowany.

Możesz użyć nazwy symbolu preprocesora innej niż DEBUG, ponieważ niektóre źródła również definiują ten symbol (np. progs używając ./configure poleceń do przygotowania do budowy). Wydawało mi się to naturalne, kiedy go rozwinąłem. Rozwinąłem go w aplikacji, w której DLL jest używany przez coś innego, i bardziej opłaca się wysyłać wydruki logów do pliku; ale zmiana go na vprintf() też by zadziałała.

Mam nadzieję, że oszczędzi to wielu z was smutku z powodu znalezienia najlepszego sposobu aby zrobić logowanie debugowania; lub pokazuje jeden może wolisz. Od dziesięcioleci próbuję to rozgryźć. Działa w MSVC 2012 & 2015, a więc prawdopodobnie na gcc;, a także prawdopodobnie działa na wielu innych, ale nie testowałem go na nich.

Wierzę, że ta odmiana tematu daje kategorie debugowania bez konieczności posiadania osobnej nazwy makra dla kategorii.

Użyłem tej odmiany w projekcie Arduino, gdzie przestrzeń programu jest ograniczona do 32K, a pamięć dynamiczna jest ograniczona do 2k. dodanie instrukcji debug i ciągów debugowania śledzenia szybko zużywa przestrzeń. Dlatego ważne jest, aby móc ograniczyć ślad debugowania, który jest zawarty w czasie kompilacji do niezbędnego minimum za każdym razem, gdy kod jest zbudowany.

Debugowanie.h

#ifndef DEBUG_H
#define DEBUG_H

#define PRINT(DEBUG_CATEGORY, VALUE)  do { if (DEBUG_CATEGORY & DEBUG_MASK) Serial.print(VALUE);} while (0);

#endif

#define DEBUG_MASK 0x06
#include "Debug.h"

...
PRINT(4, "Time out error,\t");
...