Как создать функцию только для отладки, которая принимает список переменных аргументов?Как printf()
-
08-06-2019 - |
Вопрос
Я бы хотел создать функцию ведения журнала отладки с теми же параметрами, что и printf
.Но такой, который может быть удален препроцессором во время оптимизированных сборок.
Например:
Debug_Print("Warning: value %d > 3!\n", value);
Я просмотрел переменные макросы, но они доступны не на всех платформах. gcc
поддерживает их, msvc
не делает этого.
Решение
Я все еще делаю это по-старому, определяя макрос (XTRACE, ниже), который соотносится либо с no-op, либо с вызовом функции со списком переменных аргументов.Внутренне вызовите 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
Ну, это можно немного почистить, но это основная идея.
Другие советы
Вот как я делаю отладочные распечатки на 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 не используется, компилятор вообще не генерирует код для этой строки.
Вот кое-что, что я делаю на C / C ++.Во-первых, вы пишете функцию, которая использует материал varargs (смотрите Ссылку в публикации Stu).Затем сделайте что-то вроде этого:
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, и вся строка будет удалена в неотладочном коде.
Еще один интересный способ отключить вариационные функции - это:
#define function sizeof
@Кодирование колеса:
Есть одна небольшая проблема с вашим подходом.Рассмотрим такой вызов, как
XTRACE("x=%d", x);
Это прекрасно работает в отладочной сборке, но в релизной сборке оно будет расширено до:
("x=%d", x);
Который является совершенно законным C и будет компилироваться и обычно запускаться без побочных эффектов, но генерирует ненужный код.Подход, который я обычно использую для устранения этой проблемы, заключается в следующем:
Заставьте функцию XTrace возвращать значение int (просто возвращайте 0, возвращаемое значение не имеет значения)
Измените #define в предложении #else на:
0 && XTrace
Теперь релизная версия будет расширена до:
0 && XTrace("x=%d", x);
и любой приличный оптимизатор выбросит все это, поскольку оценка короткого замыкания предотвратила бы выполнение чего-либо после && .
Конечно, как только я написал это последнее предложение, я понял, что, возможно, исходная форма тоже может быть оптимизирована, и в случае побочных эффектов, таких как вызовы функций, передаваемые в качестве параметров в XTrace, это может быть лучшим решением, поскольку оно гарантирует, что отладочная и релизная версии будут вести себя одинаково.
В 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
.
Ах, 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);
}
Затем оберните все это в макрос.
На каких платформах они недоступны?stdarg является частью стандартной библиотеки:
http://www.opengroup.org/onlinepubs/009695399/basedefs/stdarg.h.html
Любая платформа, не предоставляющая его, не является стандартной реализацией C (или очень, очень старой).Для этого вам придется использовать varargs:
http://opengroup.org/onlinepubs/007908775/xsh/varargs.h.html
Часть проблемы с такого рода функциональностью заключается в том, что часто для этого требуются переменные макросы.Они были стандартизированы сравнительно недавно (C99), и многие старые компиляторы C не поддерживают стандарт или имеют свою собственную специальную работу вокруг.
Ниже приведен заголовок debug, который я написал и который имеет несколько интересных функций:
- Поддерживает синтаксис C99 и C89 для отладочных макросов
- Включать / отключать вывод на основе аргумента функции
- Вывод в файловый дескриптор (файловый ввод-вывод)
Примечание:По какой-то причине у меня возникли небольшие проблемы с форматированием кода.
#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_ */
Взгляните на эту тему:
Это должно дать ответ на ваш вопрос.
Столкнувшись с проблемой сегодня, я решил использовать следующий макрос:
static TCHAR __DEBUG_BUF[1024]
#define DLog(fmt, ...) swprintf(__DEBUG_BUF, fmt, ##__VA_ARGS__); OutputDebugString(__DEBUG_BUF)
Затем вы можете вызвать функцию следующим образом:
int value = 42;
DLog(L"The answer is: %d\n", value);
Это то, что я использую:
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 */
}
который абсолютно ничего не стоит во время выполнения, когда флаг _DEBUG_LOG выключен.
Это TCHAR-версия ответа пользователя, поэтому она будет работать в формате ASCII (Нормальный), или режим Unicode (более или менее).
#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
}
Я говорю "более или менее", потому что это не будет автоматически преобразовывать строковые аргументы ASCII в WCHAR, но это должно избавить вас от большинства проблем с Юникодом, не беспокоясь о переносе строки формата в TEXT () или предварении ее символом L.
В значительной степени производный от MSDN:Получение кода последней ошибки