How to use #ifndef with macro argument?

Question

I have a simple code in header.h-

#define SWAP(a, b)  {a ^= b; b ^= a; a ^= b;} 

This header.h is included in a code.c file, but my requirement is- I want SWAP to be checked first like-

#ifndef SWAP(a, b)
#define SWAP(a, b)  {a ^= b; b ^= a; a ^= b;}
#endif

Is this correct or I don't have to provide the argument to the first line?

Answer 1

You want to code

#ifndef SWAP
#define SWAP(a, b)  {a ^= b; b ^= a; a ^= b;}
#endif

The #ifndef is just looking into the preprocessor's symbol table (for the presence or absence of some given preprocessor symbol). It does not care about the arguments of your SWAP macro.

Of course in genuine C++11 you should prefer the standard std::swap function. It is typesafe, more readable, and safer (think about SWAP(t[i++],i) as a misbehaving example).

Answer 2

It is incorrect.

The correct usage of #ifndef is:

#ifndef SWAP
#define SWAP(a, b)  {a ^= b; b ^= a; a ^= b;}
#endif

From http://en.cppreference.com/w/cpp/preprocessor/conditional:

#ifndef identifier

Answer 3

Before asking the question you could have looked into the standard to get an idea of how it is used.

From standard - §6.10.1p5

Preprocessing directives of the forms

# ifdef identifier new-line groupopt
# ifndef identifier new-line groupopt

check whether the identifier is or is not currently defined as a macro name. Their conditions are equivalent to #if defined identifier and #if !defined identifier respectively.

Then again if you are not sure what is the macro name and what are the parameters etc..

From standard §6.10.3.p10

A preprocessing directive of the form

# define identifier lparen identifier-listopt ) replacement-list new-line
# define identifier lparen ... ) replacement-list new-line
# define identifier lparen identifier-list , ... ) replacement-list new-line

defines a function-like macro with parameters, whose use is similar syntactically to a function call. The parameters are specified by the optional list of identifiers, whose scope extends from their declaration in the identifier list until the new-line character that terminates the #define preprocessing directive. Each subsequent instance of the function-like macro name followed by a ( as the next preprocessing token introduces the sequence of preprocessing tokens that is replaced by the replacement list in the definition (an invocation of the macro)....

The last section just will let you know enough what should be written in the ifndef in place of identifier. It is clear from the highlighted parts.

In C you have to a considerable amount of work to write a generic and correct swap macro. For two same value your swap will not work as you expect it to.

Answer 4

To briefly answer your question, it is as the other answers have already stated. The #ifdef/#ifndef conditional only cares about the macro identifier, so the arguments are not part of its syntax.

However, your macro has a couple of weaknesses that should be addressed. First, note that using the XOR-operator for swapping, although a commonly taught trick to avoid using a temporary, fails if the two arguments are the same object. This is because the result of the first XOR would be 0, and the remaining XOR steps cannot recover the original value. Second, this version of the macro fails for pointer types, because XOR wants integral types. Third, the macro invokes the arguments multiple times, which will cause problems if the argument is an expression with side effects. Fourth, compound statements in a macro should be guarded by do .. while (0) to allow the macro to expand into a statement. This makes the macro syntactically cleaner, so that a semi-colon after it is not spurious.

As explained in a separate answer, in C++, use std::swap instead of defining your own. Unfortunately, C does not provide a generic swapping utility function. However, it is not difficult to author a generic function:

static inline void swap_generic (void *a, void *b, void *t, size_t sz) {
    if (a != b) {
        memcpy(t, a, sz);
        memcpy(a, b, sz);
        memcpy(b, t, sz);
    }
}

Your macro could then invoke this function.

#ifndef SWAP
# ifdef __cplusplus
#  define SWAP(a, b) std::swap(a, b)
# else
#  define SWAP_ASSERT(X) _Static_assert(X, #X)
#  if  __STDC_VERSION__ < 201112L
#   undef SWAP_ASSERT
#   define SWAP_ASSERT(X) struct dummy
#  endif
#  define SWAP(a, b) do {                                \
       SWAP_ASSERT(sizeof(a) == sizeof(b));              \
       char t[sizeof(a) != sizeof(b) ? -1 : sizeof(a)];  \
       swap_generic(&(a), &(b), t, sizeof(a));           \
   } while (0)
# endif
#endif

Note how we use std::swap if C++ is detected.

If you use a C compiler that supports the typeof extension, then the macro can be simplified greatly, since you do not need a generic swapping function.

#ifndef SWAP
# ifdef __cplusplus
#  define SWAP(a, b) std::swap(a, b)
# else
#  define SWAP(a, b) do {                      \
       typeof(a) *p = &(a), *q = &(b), t = *p; \
       *p = *q;                                \
       *q = t;                                 \
   } while (0)
# endif
#endif

Note that the typeof version promotes better type safety.

Answer 5

#ifndef SWAP
#define SWAP(a, b)  {a ^= b; b ^= a; a ^= b;}
#endif

above change will work for c,c++11. probably it will work for all the versions of c++XX.

Answer 6

In the older days of C++ before safer smart pointers std::shared_ptr<T> & std::unique_ptr<T> came around when using new & delete & new [] & delete [] these are some older macros that I once used in C++ for helping to manage memory.

#ifndef SAFE_DELETE
    #define SAFE_DELETE(p)  { if(p) { delete (p); (p) = nullptr; } }
#endif

#ifndef SAFE_DELETE_ARRAY
    #define SAFE_DELETE_ARRAY(p)    { if(p) { delete [] (p); (p) = nullptr; } }
#endif 

Similar to what you are trying to achieve: the design of these types of macros typically look to see if the tag - identifier is not yet defined. If it isn't then you define the name along with its parameter and functionality, then you end the if definition. Also as a side note when working with macros it may seem like over doing it but it is always advisable to enclose each parameter name in parenthesis. So in your case you would want something like:

#ifndef SWAP
    #define SWAP(a, b)  if ( (a) != (b) ) { \
                            ((a) ^= (b));   \
                            ((b) ^= (a));   \
                            ((a) ^= (b));   \
                        } else {            \ 
                            ((a) = (a));    \
                            ((b) = (b));    \
                        }                   
#endif

Now the above macro is simplistic and it doesn't prevent from invalid types such as pointers, expressions, references etc., but it should work with any built in default basic types.