Wie erstellen Sie eine Nur-Debug-Funktion, die eine variable Argumentliste verwendet? Wie printf()

Ich möchte eine Debug-Protokollierungsfunktion mit denselben Parametern wie erstellen printf. Aber eines, das vom Präprozessor während optimierter Builds entfernt werden kann.

Zum Beispiel:

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

Ich habe mir verschiedene Makros angesehen, aber diese sind nicht auf allen Plattformen verfügbar. gcc unterstützt sie, msvc nicht.

Ich mache es immer noch auf die alte Art, indem ich ein Makro (XTRACE, unten) definiere, das entweder mit einer No-Op oder einem Funktionsaufruf mit einer variablen Argumentliste korreliert. Rufen Sie intern vsnprintf auf, damit Sie die printf-Syntax beibehalten können:

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

Dann ein typischer #ifdef-Schalter:

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

Nun, das kann ziemlich aufgeräumt werden, aber es ist die Grundidee.

So debugge ich Ausdrucke in C++. Definieren Sie ‘dout’ (debug out) wie folgt:

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

Im Code verwende ich ‘dout’ genau wie ‘cout’.

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

Wenn der Präprozessor ‘dout’ durch ‘0 && cout’ ersetzt, beachten Sie, dass << eine höhere Priorität als && hat und die Kurzschlussauswertung von && die gesamte Zeile zu 0 auswertet. Da die 0 nicht verwendet wird, generiert der Compiler überhaupt keinen Code für diese Zeile.

Hier ist etwas, das ich in C/C++ mache. Zunächst schreiben Sie eine Funktion, die das varargs-Zeug verwendet (siehe den Link in Stus Beitrag). Dann mach sowas:

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

Sie müssen sich nur daran erinnern, beim Aufrufen der Debug-Funktion doppelte Klammern zu verwenden, und die gesamte Zeile wird in Nicht-DEBUG-Code entfernt.

Ah, vsprintf() war das, was ich vermisst habe. Ich kann dies verwenden, um die Variablenargumentliste direkt an printf () zu übergeben:

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

Dann packen Sie das Ganze in ein Makro.

Eine weitere unterhaltsame Möglichkeit, variadische Funktionen auszugliedern, ist:

#define function sizeof

@CodingTheWheel:

Es gibt ein kleines Problem mit Ihrem Ansatz. Betrachten Sie einen Anruf wie z

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

Dies funktioniert gut im Debug-Build, aber im Release-Build wird es erweitert zu:

("x=%d", x);

Das ist vollkommen legitimes C und wird normalerweise ohne Nebenwirkungen kompiliert und ausgeführt, generiert aber unnötigen Code. Der Ansatz, den ich normalerweise verwende, um dieses Problem zu beseitigen, ist:

1. Lassen Sie die XTrace-Funktion ein int zurückgeben (geben Sie einfach 0 zurück, der Rückgabewert spielt keine Rolle)

2. Ändern Sie das #define in der #else-Klausel in:

   0 && XTrace
   

Jetzt wird die Release-Version erweitert auf:

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

und jeder anständige Optimierer wird das Ganze wegwerfen, da die Kurzschlussauswertung alles nach dem && daran gehindert hätte, jemals ausgeführt zu werden.

Gerade als ich diesen letzten Satz schrieb, wurde mir natürlich klar, dass vielleicht auch die ursprüngliche Form wegoptimiert werden könnte und im Fall von Seiteneffekten, wie Funktionsaufrufen, die als Parameter an XTrace übergeben werden, eine bessere Lösung sein könnte, da dies der Fall sein wird Stellen Sie sicher, dass sich Debug- und Release-Versionen gleich verhalten.

In C++ können Sie den Streaming-Operator verwenden, um die Dinge zu vereinfachen:

#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

und verwende es wie folgt:

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

Sie können dann angepasste Ablaufverfolgungsausgaben für Klassen auf die gleiche Weise implementieren, wie Sie es für die Ausgabe an tun würden std::cout.