È possibile usare i puntini di sospensione nella macro? Può essere convertito in modello?

Question

Dopo aver implementato CLogClass per rendere decente la registrazione, ho anche definito la macro, ma funziona solo con un parametro ...

class CLogClass
{ 
public:
       static void DoLog(LPCTSTR sMessage, ...);
};
#define DebugLog(sMessage, x) ClogClass::DoLog(__FILE__, __LINE__, sMessage, x)

Beh, fallisce quando viene chiamato con più di 2 parametri :( ... È possibile evitarlo? Può in qualche modo essere tradotto in template?

EDIT: le macro Variadic sono state introdotte in VS 2005 (ma attualmente sono in VS 2003 ...). Qualche consiglio?

Answer 1

È possibile che una macro MYLOG restituisca un oggetto functor personalizzato che accetta un numero variabile di argomenti.

#include <string>
#include <cstdarg>

struct CLogObject {

  void operator()( const char* pFormat, ... ) const {
    printf( "[%s:%d] ", filename.c_str(), linenumber );
    va_list args;
    va_start( args, pFormat );
    vfprintf( stderr, pFormat, args );
    va_end( args );
  }

  CLogObject( std::string filename, const int linenumber )
    : filename( filename ), linenumber( linenumber )
  {}
  std::string filename;
  int linenumber;
};

#define MYLOG CLogObject( __FILE__, __LINE__ )


int _tmain(int argc, _TCHAR* argv[])
{

  MYLOG( "%s, %d", "string", 5 );
  return 0;
}

Nota che non è così difficile passare alla variante "type-safe" toccata da questa risposta : non hai bisogno di argomenti variadici a causa dell'effetto concatenamento di operator<<.

struct CTSLogObject {

  template< typename T >
  std::ostream& operator<<( const T& t ) const {
    return std::cout << "[" << filename << ":" << linenumber << "] ";
  }

  CTSLogObject( std::string filename, const int linenumber )
    : filename( filename ), linenumber( linenumber )
  {}
  std::string filename;
  int linenumber;
};
#define typesafelog CTSLogObject( __FILE__, __LINE__ )

int _tmain(int argc, _TCHAR* argv[])
{
  typesafelog << "typesafe" << ", " << 5 << std::endl;
  return 0;
}

Answer 2

Le tue domande fanno appello a due risposte. Vuoi fare la funzione di registrazione universale, che funziona come printf ma può essere completamente personalizzata. Quindi hai bisogno di:

• macro che accetta un numero variabile di argomenti
• funzione che accetta un numero variabile di argomenti

Ecco il tuo esempio di codice adatapted:

#include <stdio.h>
#include <stdarg.h>


class CLogClass
{
public:
    static void DoLogWithFileLineInfo( const char * fmt, ... )
    {
        va_list ap;
        va_start( ap, fmt );
        vfprintf( stderr, fmt, ap );
        va_end( ap );
    }

};


#define MYLOG(format, ...) CLogClass::DoLogWithFileLineInfo("%s:%d " format , __FILE__, __LINE__, __VA_ARGS__)

int main()
{
    MYLOG("Hello world!\n", 3); // you need at least format + one argument to your macro
    MYLOG("%s\n", "Hello world!");
    MYLOG("%s %d\n", "Hello world!", 3);
}

Le macro variabili sono state introdotte in C99, quindi funzionerà con compilatori che supportano C99 o C ++ 0x. L'ho provato con successo con gcc 3.4.2 e Visual Studio 2005.

Argomenti variabili delle funzioni sono presenti da sempre, quindi non preoccuparti della compatibilità qui.

Probabilmente è possibile farlo con un modello di meta-programmazione ma non vedo l'interesse dato la semplicità del codice sopra.

Come ultima nota, perché usare un metodo statico in una classe vuota anziché in una funzione?

Answer 3

class Log {
    stringstream buffer;
    public:
        class Proxy {
            public:
                Proxy(Log& p) : parent(p) {}
                template<class T>
                Proxy& operator,(T const& t) {
                    parent.buffer << t;
                    return *this;
                }
                ~Proxy() {
                    parent.buffer << endl;
                    cout << parent.buffer.str();
                    parent.buffer.str("");
                }
            private:
                CLog& parent;
        };

        template<class T>
        Proxy operator<<(T const& t) {
            buffer << t;
            return Proxy(*this);
        }
};

Può essere banalmente esteso per scrivere timestamp, verificare il livello di Google, scrivere su file, ecc.

O, più semplicemente ma meno flessibile:

class Log {
    public:
        class Proxy {
            public:
                template<class T>
                Proxy& operator,(T const& t) {
                    cout << t;
                    return *this;
                }
                ~Proxy() {
                    cout << endl;
                }
        };

        template<class T>
        Proxy operator<<(T const& t) {
            cout << t;
            return Proxy();
        }
};

Utilizzo:

Log log;
void f() {
     log << "hey, my age is ", age;
}

Answer 4

Tenderei ad usare una funzione extern visibile globalmente piuttosto che una macro in questa istanza, e risolvere i puntini di sospensione in questa funzione usando un va_list. Vedi il mio post precedente per un esempio su come raggiungere questo .