C #определение макроса для отладки печати

Я использую что-то вроде этого:

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

чем я просто использую D в качестве префикса:

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

компилятор видит код отладки, нет проблемы с запятой, и он работает везде. Также он работает, когда printf недостаточно, скажем, когда вы должны сбросить массив или вычислить некоторое диагностическое значение, избыточное для самой программы.

EDIT: хорошо, это может создать проблему, когда есть else где-то рядом, что может быть перехвачен этого вводят if. Это версия, которая идет по нему:

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

для портативной (ISO C90) реализации вы можете использовать двойные круглые скобки, например;

#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;
}

или (hackish, не рекомендовал бы его)

#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;
}

Я бы сделал что-то вроде

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

Я думаю, что это чище.

вот версия, которую я использую:

#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)

по данным http://gcc.gnu.org/onlinedocs/cpp/Variadic-Macros.html, должно быть ## до __VA_ARGS__.

в противном случае, макрос #define dbg_print(format, ...) printf(format, __VA_ARGS__) не будет компилировать следующий пример:dbg_print("hello world");.

Это то, что я использую:

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

Он имеет хорошее преимущество для правильной обработки printf, даже без дополнительных аргументов. В случае DBG ==0 даже самый тупой компилятор не получает ничего, чтобы жевать, поэтому код не генерируется.

мой любимый из ниже var_dump, который при вызове в качестве:

var_dump("%d", count);

выпускает продукцию как:

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

кредит @ "Jonathan Leffler". Все C89-счастливы:

код

#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)

Я много лет мучился над тем, как это сделать, и я только недавно придумал это решение, прежде чем увидеть этот вопрос. Во-первых, при разнице с ответ Леффлера, я не вижу его аргумента, что отладочные отпечатки всегда должны быть скомпилированы. Да, у вас есть отладочные отпечатки, которые иногда не компилируются, но их не так сложно компилировать и тестировать перед завершением проекта. Допустим, что нет. Самое худшее, что происходит, это то, что вы должны исправить несколько горсти на большой проект. Если ваш проект не HUUUUGE, это проще, чем это.

мое решение обеспечивает уровни детализации отладки; и если вы установите его на самый высокий уровень, все они компилируются. Если вы недавно использовали высокий уровень детализации отладки, они, вероятно, все уже компилируются. Мне никогда не требовалось больше трех уровней, но Джонатан говорит, что использовал девять. Его метод также может иметь уровни детализации отладки печати. Шахту можно легко расширить для того чтобы поддержать любое число уровнях, и его может поддерживать любое количество уровней. Использование моего метода может быть проще; требуется всего два оператора при использовании в коде (хотя я также использую третий).

против стоимости дополнительный шаг тестирования их, чтобы увидеть, что они будут компилироваться перед доставкой, это

1. вы должны доверять им, чтобы оптимизироваться, что, по общему признанию, должно произойти, если у вас есть достаточный уровень оптимизации.
2. кроме того, они, вероятно, не если вы делаете релиз компиляции с оптимизацией выключен в целях тестирования (что правда редко), и они почти наверняка не во время отладки, тем самым выполнив десятки или сотни "если (отладка)" заявления во время выполнения, поэтому замедление исполнения (это мой принцип возражения), и менее важно, увеличивая свой исполняемый файл или DLL размер; и, следовательно, выполнения и время компиляции. Джонатан, однако, сообщает мне, что его метод можно сделать, чтобы также не компилировать операторы в все.

ветви на самом деле относительно довольно дорогостоящие в современных процессорах предварительной выборки. Возможно, это не так уж важно, если ваше приложение не является критичным по времени; но если производительность является проблемой, то да, достаточно большой, что я предпочел бы выбрать несколько более быстрый отладочный код (и, возможно, более быстрый выпуск, в редких случаях, как отмечалось).

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

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

использование макросов

Для использовать его, просто do:

DEBUGLOG_INIT("afile.log");

писать в файл журнала, просто так:

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

чтобы закрыть его, вы:

DEBUGLOG_CLOSE();

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

затем, когда вы хотите включить печать отладки, просто отредактируйте первый #define в заголовке файл сказать, например,

#define DEBUG 1

для утверждения лесозаготовки компилировать ничего, ничего

#define DEBUG 0

Если вам нужна информация из часто выполняется кусок кода (т. е. высокий уровень детализации), вы можете написать:

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

если вы определяете DEBUG как 3, уровни регистрации 1, 2 и 3 компилируются. Если вы установите его на 2, вы получите уровни регистрации 1 и 2. Если вы установите его в 1, вы получите только операторы уровня ведения журнала 1.

что касается цикла do-while, так как это вычисляет либо одну функцию, либо ничего, вместо оператора if цикл не требуется. Хорошо, накажите меня за использование C вместо C++ IO (и Qt QString::arg () - более безопасный способ форматирования переменных, когда в Qt тоже - это довольно гладко, но занимает больше кода, и документация по форматированию не так организована, как могла бы быть, но все же я нашел случаи, когда это предпочтительнее), но вы можете поместить любой код в Qt .cpp файл, который вы хотите. Это также может быть класс, но тогда вам понадобится чтобы создать экземпляр и идти в ногу с ним, или сделать новый() и сохранить его. Таким образом, вы просто отбрасываете операторы #include, init и необязательно close в свой источник, и вы готовы начать его использовать. Однако это был бы прекрасный класс, если вы так склонны.

раньше я видел много решений, но ни одно из них не соответствовало моим критериям так, как это.

1. он может быть расширен, чтобы сделать столько уровней, сколько вам нравится.
2. он компилируется в ничто, если нет печатающий.
3. он централизует IO в одном удобном для редактирования месте.
4. он гибкий, используя форматирование printf.

кроме того,

1. он не требует взлома для печати без аргументов (например,ERRLOG_LOG(3, "got here!");); таким образом, позволяя вам использовать, например, Qt безопаснее .арг() форматирование. Он работает на MSVC, и, следовательно, вероятно, gcc. Он использует ## на #defines, который не является стандартным, как указывает Леффлер, но широко поддерживается. (Вы можете перекодировать его не использовать ## при необходимости, но вам придется использовать Хак, такой, как он обеспечивает.)

предупреждение: Если вы забыли указать аргумент уровня ведения журнала, MSVC бесполезно утверждает, что идентификатор не определен.

вы можете использовать имя символа препроцессора, отличное от DEBUG, так как некоторый источник также определяет этот символ (например. прогс с помощью ./configure команды для подготовки к строительству). Мне казалось естественным, когда я его развивал. Я разработал его в приложение, где DLL используется чем-то другим, и это больше монастырь для отправки отпечатков журналов в файл; но изменение его на vprintf() тоже будет работать нормально.

Я надеюсь, что это избавит многих из вас от горя по поводу выяснения лучшего способа ведения журнала отладки; или показывает вам тот, который вы могли бы предпочесть. Я вяло пытался разобраться в этом десятилетиями. Работает в MSVC 2012 & 2015 и, следовательно, вероятно, на gcc; а также, вероятно, работает на многих других, но я не тестировал его на их.

Я считаю, что этот вариант темы дает категории отладки без необходимости иметь отдельное имя макроса для каждой категории.

я использовал этот вариант в проекте Arduino, где пространство программы ограничено 32K, а динамическая память ограничена 2K. Добавление операторов отладки и строк отладки трассировки быстро использует пространство. Поэтому важно иметь возможность ограничить трассировку отладки, которая включается во время компиляции, до минимума, необходимого каждый раз, когда код построенный.

"отладка".h

#ifndef DEBUG_H
#define DEBUG_H

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

#endif

призвание .файл cpp

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

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