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

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

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

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

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

Еще один интересный способ избавиться от вариативных функций:

#define function sizeof

@CodingTheWheel:

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

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

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

("x=%d", x);

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

1. Сделайте так, чтобы функция XTrace возвращала int (просто верните 0, возвращаемое значение не имеет значения)

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

   0 && XTrace
   

Теперь релизная версия расширится до:

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

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

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

Вот как я отлаживаю распечатки на 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 не используется, компилятор не генерирует никакого кода. для этой строки.

Столкнувшись с проблемой сегодня, я решил воспользоваться следующим макросом:

    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, но он должен избавить вас от большинства циклов Unicode, не беспокоясь о переносе строки формата в TEXT () или перед ней с помощью L .

В значительной степени заимствован из MSDN: получение кода последней ошибки

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

#define show(args...) describe(#args,args);
template<typename T>
void describe(string var_name,T value)
{
    clog<<var_name<<" = "<<value<<" ";
}

template<typename T,typename... Args>
void describe(string var_names,T value,Args... args)
{
    string::size_type pos = var_names.find(',');
    string name = var_names.substr(0,pos);
    var_names = var_names.substr(pos+1);
    clog<<name<<" = "<<value<<" | ";
    describe(var_names,args...);
}

Образец использования:

int main()
{
    string a;
    int b;
    double c;
    a="string here";
    b = 7;
    c= 3.14;
    show(a,b,c);
}

Выход :

a = string here | b = 7 | c = 3.14 

Взгляните на эту ветку:

• Как сделать вариативный макрос (переменное количество аргументов)

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

Вот кое-что, что я делаю на 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.

Ах, 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);
}

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

In C++ you can use the streaming operator to simplify things:

#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

and use it like:

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

You can then implement customised trace output for classes in much the same way you would do it for outputting to std::cout .

Частично проблема с такой функциональностью заключается в том, что часто требуются макросы с переменным числом аргументов. Они были стандартизированы сравнительно недавно (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_ */