Как создать функцию только для отладки, которая принимает список переменных аргументов? Мне нравится printf () - PullRequest
Новая
       69

Как создать функцию только для отладки, которая принимает список переменных аргументов? Мне нравится printf ()

37 голосов
/ 19 августа 2008

Я бы хотел создать функцию ведения журнала отладки с теми же параметрами, что и printf. Но тот, который может быть удален препроцессором во время оптимизированных сборок.

Например: 

Debug_Print("Warning: value %d > 3!\n", value);

Я смотрел макросы variadic, но они доступны не на всех платформах. gcc поддерживает их, msvc не поддерживает.

Ответы [ 13 ]

23 голосов
/ 19 августа 2008

Я все еще делаю это по-старому, определяя макрос (XTRACE, ниже), который соотносится либо с неоперацией, либо с вызовом функции со списком переменных аргументов. Внутренне вызовите vsnprintf, чтобы сохранить синтаксис printf: 

#include <stdio.h>

void XTrace0(LPCTSTR lpszText)
{
   ::OutputDebugString(lpszText);
}

void XTrace(LPCTSTR lpszFormat, ...)
{
    va_list args;
    va_start(args, lpszFormat);
    int nBuf;
    TCHAR szBuffer[512]; // get rid of this hard-coded buffer
    nBuf = _vsnprintf(szBuffer, 511, lpszFormat, args);
    ::OutputDebugString(szBuffer);
    va_end(args);
}

Затем типичный переключатель #ifdef: 

#ifdef _DEBUG
#define XTRACE XTrace
#else
#define XTRACE
#endif

Ну, это можно немного убрать, но это основная идея.

21 голосов
/ 16 сентября 2008

Вот как я отлаживаю распечатки в C ++. Определите 'dout' (отладку) следующим образом: 

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

В коде я использую 'dout' так же, как 'cout'. 

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

Если препроцессор заменяет 'dout' на '0 && cout', обратите внимание, что << имеет более высокий приоритет, чем &&, и при оценке короткого замыкания && вся строка оценивается как 0. Поскольку 0 не используется, компилятор не генерирует no код вообще для этой строки. </p>

11 голосов
/ 19 августа 2008

Вот что я делаю в C / C ++. Во-первых, вы пишете функцию, которая использует материал varargs (см. Ссылку в публикации Стю). Затем сделайте что-то вроде этого: 


 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" ));

Все, что вам нужно помнить, это использовать двойные парены при вызове функции отладки, и вся строка будет удалена в коде, отличном от DEBUG.

4 голосов
/ 20 августа 2008

Еще один забавный способ заглушить переменные функции: 

#define function sizeof
3 голосов
/ 11 сентября 2008

@ CodingTheWheel:

Есть одна небольшая проблема с вашим подходом. Рассмотрим вызов, такой как 

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

Это прекрасно работает в отладочной сборке, но в выпускной сборке она расширится до: 

("x=%d", x);

Это вполне допустимый C, который компилируется и обычно запускается без побочных эффектов, но генерирует ненужный код. Подход, который я обычно использую для устранения этой проблемы:

  1. Заставить функцию XTrace возвращать int (просто вернуть 0, возвращаемое значение не имеет значения)

  2. Измените #define в предложении #else на: 

    0 && XTrace

Теперь версия выпуска будет расширена до: 

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

и любой приличный оптимизатор выбросит все это, так как оценка короткого замыкания помешала бы чему-либо после выполнения &&.

Конечно, как только я написал это последнее предложение, я понял, что, возможно, исходная форма тоже может быть оптимизирована, и в случае побочных эффектов, таких как вызовы функций, передаваемых в качестве параметров в XTrace, это может быть лучшим решением поскольку он гарантирует, что версии отладки и выпуска будут вести себя одинаково.

2 голосов
/ 20 августа 2008

В C ++ вы можете использовать потоковый оператор для упрощения вещей: 

#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

и используйте его как: 

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

Затем вы можете реализовать настраиваемый вывод трассировки для классов практически так же, как вы сделали бы это для вывода в std::cout.

2 голосов
/ 19 августа 2008

Ах, vsprintf () - это то, чего мне не хватало. Я могу использовать это для прямой передачи списка аргументов в 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);
}

Затем заверните все это в макрос.

1 голос
/ 27 марта 2009

Посмотрите на эту тему:

Это должно ответить на ваш вопрос.

1 голос
/ 04 сентября 2008

Часть проблемы с этим типом функциональности состоит в том, что часто это требует вариационные макросы. Они были стандартизированы сравнительно недавно (C99), и многие старые компиляторы C не поддерживают стандарт или имеют свою специальную работу вокруг.

Ниже приведен написанный мной отладочный заголовок, который имеет несколько интересных функций:

  • Поддерживает синтаксис C99 и C89 для макросов отладки
  • Включить / отключить вывод на основе аргумента функции
  • Вывод в дескриптор файла (файл io)

Примечание. По некоторым причинам у меня возникли небольшие проблемы с форматированием кода. 

#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_ */
1 голос
/ 19 августа 2008

На каких платформах они недоступны? stdarg является частью стандартной библиотеки:

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

Любая платформа, не предоставляющая ее, не является стандартной реализацией C (или очень, очень старой). Для них вам придется использовать varargs:

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

Страница:
...