Click here to Skip to main content
Click here to Skip to main content

Defining a unique macro receiving multiple arguments of any type

, 28 Dec 2003
Rate this:
Please Sign up or sign in to vote.
This article describes how to define a macro receiving multiple arguments of multiple types and convert it automatically to a concatenated string


One of the common use of C++ macros is to deal with functions like tracing or logging to a file. As these functions usually works with strings generated by dynamic data, passing multiple arguments to the macro without having to convert each one to a string may be useful, and sometimes the developer don't know the way to go. It can be made by a lot of ways, and the Code Project have similar articles on this topic but the solution I present here use a different approach that result in a clean syntax without character formatting like "%d" / "%s" / "%c"... a sample usage may be:

MYTRACE( “The username found is ”, strUserName,
         “ having ”, intAge,
         “ years old. The database key is ”, lngUserKey );

I'll use tracing as an example application, a real tracing class may consider issues like multithreading code protection and others that are out the scope of this article.


Suppose you have to trace information in your code. Usually you'll encapsulate it in a class:

class MyTraceClass
   static void Trace( const string &message )
      // trace code...

As we need a easy way to disable the tracing code on release builds, we'll define a macro, like:

#define MYTRACE( x ) MyTraceClass::Trace( x )
It works fine, but this way we can pass just one string argument. Some programmers define various macro versions like TRACE / TRACE2 / TRACE3... one for each number of arguments, clearly it isn't an elegant solution because the macro user need to know the correct macro version accordingly the arguments being passed. Using va_arg the problem can be solved. The MFC defines the TRACE macro as:
void AFX_CDECL AfxTrace(LPCTSTR lpszFormat, ...);
#define TRACE  ::AfxTrace
So we can pass many arguments to the macro using the printf format specifiers like "%d" / "%s" / "%c"...
int i=10;
   TRACE( “Iteration number:  %d”, i );

The code above works fine but we have to be aware of the format specifiers, and we can't pass a non-LPCTSTR data as the first argument to TRACE without manually convert to LPCTSTR. As the tracing code will be "turned off", any aditional code is a overhead and will clutter the rest of code.

The proposed solution

Using templates and overloading, the macro can be called with a variable number of arguments of any type. The stringstream class helps to easily convert each argument to string, composing the final information.

First, the macro will be defined to the name of the static method:

#define MYTRACE  MyTraceClass::Trace

To receive arguments of any type, we'll define the tracing function receiving typename arguments:

template<typename T1> static void Trace( T1 par1 );

To receive multiple arguments, provide various versions of the overloaded method. Now the arguments can be converted to string using the stringstream class:

template<typename T1, typename T2> static void Trace( T1 par1, T2 par2 )
stringstream ss;
   ss << par1 << par2;
   Trace( ss.str() );

template<typename T1, typename T2, typename T3> 
  static void Trace( T1 par1, T2 par2, T3 par3 )
stringstream ss;
   ss << par1 << par2 << par3;
   Trace( ss.str() );

template<typename T1, typename T2, typename T3, typename T4> 
  static void Trace( T1 par1, T2 par2, T3 par3, T4 par4 )
stringstream ss;
   ss << par1 << par2 << par3 << par4;
   Trace( ss.str() );


This way we can call the macro with syntaxes like below. The screen illustrates a simple cout output.

MYTRACE( "Method Add() Called !" );
MYTRACE( "Iteration number: ", i );
MYTRACE( “The username found is ”, strUserName,
         “ having ”, intAge,
         “ years old. The database key is ”, lngUserKey );

Obviously the number of arguments can't exceed the maximum defined on overloaded methods, but it cannot be considered a problem, tracing / logging code usually don't need too much arguments, at worse it's easy to extend the class to support more overloaded methods.

This is my first article on Code Project. I hope someone might find it useful Smile | :)


This article has no explicit license attached to it but may contain usage terms in the article text or the download files themselves. If in doubt please contact the author via the discussion board below.

A list of licenses authors might use can be found here


About the Author

Web Developer
Brazil Brazil
I live in São Paulo - Brazil - where I have my tiny C++ \ Win32 \ .NET training company: NEXSUN
I have worked with many programming languages like VB / C++ / Java / C# but I´m mainly interested in: C++ forever Smile | :) and the .NET framework. Now I'm IBM-OOAD, OMG-OCUP, MCP, MCAD, MCSD, SCJP, MCSD.NET, MCTS, MCPD.

Comments and Discussions

GeneralATLTRACE Pinmembernyc12322-Jan-04 10:34 
GeneralRe: ATLTRACE PinmemberGuimaSun2-May-04 5:59 
Generalcool. and there is another way Pinmembertimepalette3-Jan-04 19:47 
GeneralRe: cool. and there is another way Pinmemberkozlowski4-Jan-04 13:50 
GeneralRe: cool. and there is another way Pinmembertarzoon5-Jan-04 2:52 
GeneralRe: cool. and there is another way Pinmemberkozlowski5-Jan-04 23:47 
GeneralRe: cool. and there is another way - An alternative Pinmemberheyto6-Jan-04 5:36 

One alternative, that might provide the best of both worlds it to used two different types of streams and macro selecting between them. One providing useful logging, the other to (hopefully*) compile away to nothing.
*I can't check this works, as I don't have a professional copy of MSVC so can't turn on the required level of optimisation.
The following example tries to illustrate this uses a custom stream, which does nothing with it's input (NullOStream) and standard out (std::out).
If anyone's interested in a full blown article, then let me know and I'll expand on my flavour of a stream based logger (streams, filtering, stack dumping) But as there are already a number of good logging articles on CodeProject, so I've held back until now.
For anyone who's interested an implementation of my logger can be found at under src/logging

Disclaimer: I don't have a compiler in front of me, so this probably contains typos.
class NullOStream
     * Handle all value types, but do nothing with them.
     * (hopefully this in-line method will be optimised away)
    template &lttypename T&gt
    NullOStream& operator &lt&lt (T /*p_Value*/)
      return *this;
    static NullOStream Instance;
// Add code to provide storage and initialisation
NullOStream NullOStream::Instance;
#ifdef NDEBUG
  #define TRACE NullOStream::Instance
  #define TRACE std::cout
// usage
TRACE &lt&lt "hello world" &lt&lt aVariable &lt&lt 20;

GeneralRe: cool. and there is another way - An alternative Pinmemberkozlowski6-Jan-04 15:39 
GeneralRe: cool. and there is another way - An alternative Pinmemberheyto7-Jan-04 22:47 
GeneralRe: cool. and there is another way - An alternative Pinmemberkozlowski7-Jan-04 23:43 

General General    News News    Suggestion Suggestion    Question Question    Bug Bug    Answer Answer    Joke Joke    Rant Rant    Admin Admin   

Use Ctrl+Left/Right to switch messages, Ctrl+Up/Down to switch threads, Ctrl+Shift+Left/Right to switch pages.

| Advertise | Privacy | Terms of Use | Mobile
Web04 | 2.8.141223.1 | Last Updated 29 Dec 2003
Article Copyright 2003 by GuimaSun
Everything else Copyright © CodeProject, 1999-2014
Layout: fixed | fluid