Jak utworzyć funkcję debugowania, która pobiera listę zmiennych argumentów? Jak printf()

Tak robię debugowanie wydruków w C++. Define ' dout '(debug out) like this:

#ifdef DEBUG
#define dout cout
#else
#define dout 0 && cout
#endif

W kodzie używam 'dout' tak jak 'cout'.

dout << "in foobar with x= " << x << " and y= " << y << '\n';

Jeśli preprocesor zastąpi' dout 'na' 0 & & cout ' zauważ, że

Oto coś, co robię w C / C++. Po pierwsze, piszesz funkcję, która używa rzeczy varargs (patrz link w postach Stu). To zrób coś takiego:

 int debug_printf( const char *fmt, ... );
 #if defined( DEBUG )
  #define DEBUG_PRINTF(x) debug_printf x
 #else
   #define DEBUG_PRINTF(x)
 #endif

 DEBUG_PRINTF(( "Format string that takes %s %s\n", "any number", "of args" ));

Wszystko, co musisz pamiętać, to użycie podwójnego parena podczas wywoływania funkcji debug, a cała linia zostanie usunięta w kodzie nie-DEBUG.

Innym fajnym sposobem na stubowanie zmiennych funkcji jest:

#define function sizeof

@CodingTheWheel:

XTRACE("x=%d", x);

To działa dobrze w kompilacji debugowania, ale w kompilacji wydania rozszerzy się do:

("x=%d", x);

Który jest całkowicie legalnym C i kompiluje się i zwykle działa bez efektów ubocznych, ale generuje niepotrzebny kod. Podejście, którego zwykle używam do wyeliminowania tego problemu, to:

1. Spraw, aby funkcja XTrace zwracała wartość int (zwróć tylko 0, zwracaną wartość nie ma znaczenia)

2. Zmień # define w klauzuli # else na:

   0 && XTrace
   

Teraz wersja wydania rozszerzy się do:

0 && XTrace("x=%d", x);

I każdy porządny optymalizator wyrzuci wszystko, ponieważ ocena zwarcia uniemożliwiłaby cokolwiek po wykonaniu&&.

Oczywiście, tak jak napisałem to ostatnie zdanie, zdałem sobie sprawę, że być może oryginalna forma może być również zoptymalizowana, a w przypadku skutków ubocznych, takich jak wywołania funkcji przekazywane jako parametry do XTrace, może to być lepsze rozwiązanie, ponieważ upewni się, że wersje debug i release będą zachowywać się tak samo.

W C++ możesz użyć operatora strumieniowego do uproszczenia rzeczy:

#if defined _DEBUG

class Trace
{
public:
   static Trace &GetTrace () { static Trace trace; return trace; }
   Trace &operator << (int value) { /* output int */ return *this; }
   Trace &operator << (short value) { /* output short */ return *this; }
   Trace &operator << (Trace &(*function)(Trace &trace)) { return function (*this); }
   static Trace &Endl (Trace &trace) { /* write newline and flush output */ return trace; }
   // and so on
};

#define TRACE(message) Trace::GetTrace () << message << Trace::Endl

#else
#define TRACE(message)
#endif

I używaj go jak:

void Function (int param1, short param2)
{
   TRACE ("param1 = " << param1 << ", param2 = " << param2);
}

Możesz następnie zaimplementować spersonalizowane wyjście śledzenia dla klas w taki sam sposób, jak w przypadku wyjścia do std::cout.

Ah, vsprintf () było czymś, czego mi brakowało. Mogę użyć tego, aby przekazać listę argumentów zmiennych bezpośrednio do printf ():

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

void DBG_PrintImpl(char * format, ...)
{
    char buffer[256];
    va_list args;
    va_start(args, format);
    vsprintf(buffer, format, args);
    printf("%s", buffer);
    va_end(args);
}

Następnie zawiń całość w makro.

Na jakich platformach nie są dostępne? stdarg jest częścią biblioteki standardowej:

Http://www.opengroup.org/onlinepubs/009695399/basedefs/stdarg.h.html

Każda platforma nie dostarczająca jej nie jest standardową implementacją C (lub bardzo, bardzo starą). W tym celu musisz użyć varargs:

Http://opengroup.org/onlinepubs/007908775/xsh/varargs.h.html

Część problemu z tego rodzaju funkcjonalnością polega na tym, że często wymaga zmienne makra. Zostały one znormalizowane dość niedawno (C99), a wiele stare kompilatory C nie obsługują standardu, lub mają swoją specjalną pracę w pobliżu.

Poniżej jest nagłówek debugowania, który napisałem, że ma kilka fajnych funkcji:

• obsługuje składnię C99 i C89 dla makr debugowania
• Włącz / Wyłącz wyjście na podstawie argumentu funkcji
• Wyjście Do deskryptora pliku(Plik io)

Uwaga: z jakiegoś powodu miałem drobne problemy z formatowaniem kodu.

#ifndef _DEBUG_H_
#define _DEBUG_H_
#if HAVE_CONFIG_H
#include "config.h"
#endif

#include "stdarg.h"
#include "stdio.h"

#define ENABLE 1
#define DISABLE 0

extern FILE* debug_fd;

int debug_file_init(char *file);
int debug_file_close(void);

#if HAVE_C99
#define PRINT(x, format, ...) \
if ( x ) { \
if ( debug_fd != NULL ) { \
fprintf(debug_fd, format, ##__VA_ARGS__); \
} \
else { \
fprintf(stdout, format, ##__VA_ARGS__); \
} \
}
#else
void PRINT(int enable, char *fmt, ...);
#endif

#if _DEBUG
#if HAVE_C99
#define DEBUG(x, format, ...) \
if ( x ) { \
if ( debug_fd != NULL ) { \
fprintf(debug_fd, "%s : %d " format, __FILE__, __LINE__, ##__VA_ARGS__); \
} \
else { \
fprintf(stderr, "%s : %d " format, __FILE__, __LINE__, ##__VA_ARGS__); \
} \
}

#define DEBUGPRINT(x, format, ...) \
if ( x ) { \
if ( debug_fd != NULL ) { \
fprintf(debug_fd, format, ##__VA_ARGS__); \
} \
else { \
fprintf(stderr, format, ##__VA_ARGS__); \
} \
}
#else /* HAVE_C99 */

void DEBUG(int enable, char *fmt, ...);
void DEBUGPRINT(int enable, char *fmt, ...);

#endif /* HAVE_C99 */
#else /* _DEBUG */
#define DEBUG(x, format, ...)
#define DEBUGPRINT(x, format, ...)
#endif /* _DEBUG */

#endif /* _DEBUG_H_ */

Spójrz na ten wątek:

• Jak zrobić zmienne makro (zmienna liczba argumentów)

Powinno odpowiedzieć na twoje pytanie.

Po napotkaniu problemu dzisiaj, moim rozwiązaniem jest następujące makro:

    static TCHAR __DEBUG_BUF[1024]
    #define DLog(fmt, ...)  swprintf(__DEBUG_BUF, fmt, ##__VA_ARGS__); OutputDebugString(__DEBUG_BUF) 

Możesz wywołać funkcję w następujący sposób:

    int value = 42;
    DLog(L"The answer is: %d\n", value);

Tego używam:

inline void DPRINTF(int level, char *format, ...)
{
#    ifdef _DEBUG_LOG
        va_list args;
        va_start(args, format);
        if(debugPrint & level) {
                vfprintf(stdout, format, args);
        }
        va_end(args);
#    endif /* _DEBUG_LOG */
}

Który nie kosztuje absolutnie nic w czasie wykonywania, gdy flaga _DEBUG_LOG jest wyłączona.

Jest to wersja TCHAR odpowiedzi użytkownika, więc będzie działać jako ASCII (normal ) lub tryb Unicode (mniej więcej).

#define DEBUG_OUT( fmt, ...) DEBUG_OUT_TCHAR(       \
            TEXT(##fmt), ##__VA_ARGS__ )
#define DEBUG_OUT_TCHAR( fmt, ...)                  \
            Trace( TEXT("[DEBUG]") #fmt,            \
            ##__VA_ARGS__ )
void Trace(LPCTSTR format, ...)
{
    LPTSTR OutputBuf;
    OutputBuf = (LPTSTR)LocalAlloc(LMEM_ZEROINIT,   \
            (size_t)(4096 * sizeof(TCHAR)));
    va_list args;
    va_start(args, format);
    int nBuf;
    _vstprintf_s(OutputBuf, 4095, format, args);
    ::OutputDebugString(OutputBuf);
    va_end(args);
    LocalFree(OutputBuf); // tyvm @sam shaw
}

mówię, "mniej więcej", ponieważ nie będzie automatycznie konwertować argumentów ASCII na WCHAR, ale powinno to wydostać się z większości scrapów Unicode bez konieczności martwienia się o zawijanie ciągu formatu w TEXT () lub poprzedzającego go za pomocą L.

W dużej mierze pochodzi z MSDN: pobieranie kodu ostatniego błędu