Dirty C ++ Mac Tricks

• Safe method call
• Unused variables
• Conversion to string
• The comma in the macro argument
• Endless cycle

Some useful links

Slight cultural difference

#define FUNC(x, y) ((x)^(y))

#define VALUE 1

What is good and what is bad

1. Macros cannot be debugged

   Firstly, in fact, you can:

   Go to either project or source file properties by right-clicking and going to "Properties". Under Configuration Properties-> C / C ++ -> Preprocessor, set "Generate Preprocessed File" to either with or without line numbers, whichever you prefer. This will show what your macro expands to in context. If you need to debug it on live compiled code, just cut and paste that, and put it in place of your macro while debugging.

   So, it would be more correct to say that "macros are difficult to debug." But, nevertheless, a problem with debugging macros exists.
   
   To determine if the macro you are using needs debugging, think about whether there is something for which you want to push a breakpoint there. This can be a change in the values ​​obtained through parameters, declaration of variables, change of objects or data from the outside, and the like.
   Solutions to the problem:
   
   • completely get rid of macros by replacing them with functions (you can inline if it's important),
   • transfer the logic of macros into functions, and make the macros themselves responsible only for transferring data to these functions,
   • Use only macros that do not require debugging.
2. When you expand the macro, strange side effects may appear.

   To show which side effects are involved, they usually give an example with arithmetic operations. I will not depart from this tradition either:
   

   #include 
   #define SUM(a, b) a + b
   int main()
   {
       // Что будет в x?
       int x = SUM(2, 2);
       std::cout << x << std::endl;
       x = 3 * SUM(2, 2);
       std::cout << x << std::endl;
       return 0;
   }
   

   In the output, we expect 4 and 12, but we get 4 and 8. The fact is that the macro simply substitutes the code where it is indicated. And in this case, the code will look like this:
   

   int x = 3 * 2 + 2;
   

   This is a side effect. To make it work, as expected, we need to change our macro:
   

   #include 
   #define SUM(a, b) (a + b)
   int main()
   {
       // Что будет в x?
       int x = SUM(2, 2);
       std::cout << x << std::endl;
       x = 3 * SUM(2, 2);
       std::cout << x << std::endl;
       return 0;
   }
   

   Right now. But that is not all. Let's move on to multiplication:
   

   #define MULT(a, b) a * b
   

   We immediately write it “correctly”, but use it a little differently:
   

   #include 
   #define MULT(a, b) (a * b)
   int main()
   {
       // Что будет в x?
       int x = MULT(2, 2);
       std::cout << x << std::endl;
       x = MULT(3, 2 + 2);
       std::cout << x << std::endl;
       return 0;
   }
   

   Deja vu: again we get 4 and 8. In this case, the expanded macro will look like:
   

   int x = (3 * 2 + 2);
   

   That is, now we need to write:
   

   #define MULT(a, b) ((a) * (b))
   

   We use this version of the macro and voila:
   

   #include 
   #define MULT(a, b) ((a) * (b))
   int main()
   {
       // Что будет в x?
       int x = MULT(2, 2);
       std::cout << x << std::endl;
       x = MULT(3, 2 + 2);
       std::cout << x << std::endl;
       return 0;
   }
   

   Now everything is correct.
   
   If we ignore arithmetic operations, then, in the general case, when writing macros, we need
   

   • brackets around the whole expression
   • brackets around each macro parameter

   That is, instead of
   

   #define CHOOSE(ifC, chooseA, otherwiseB) ifC ? chooseA : otherwiseB
   

   should be
   

   #define CHOOSE(ifC, chooseA, otherwiseB) ((ifC) ? (chooseA) : (otherwiseB))
   

   
   This problem is compounded by the fact that not all types of parameters can be wrapped in brackets (a real example will be further in the article). Because of this, making high-quality macros can be quite difficult.
   
   In addition, as the encyclopedist recalled in the comments, there are times when the brackets do not save:
   

   In the section about side effects, you still forgot to mention a common problem - macros can calculate their arguments several times. In the worst case, this leads to strange side effects, in the milder one - to performance problems.
   Example
   
   

   #define SQR(x) ((x) * (x))
   y = SQR(x++);
   

   Solutions to the problem:
   
   • abandon macros in favor of functions,
   • use macros with a friendly name, simple implementation and well-placed brackets so that a programmer using such a macro can easily understand how to use it correctly.
3. Macros do not have a namespace

   If a macro is declared, it is not only global, but also simply will not allow you to use something with the same name (the macro implementation will always be substituted). The most famous example is probably the problem with min and max under Windows .
   The solution is to choose names for macros that are less likely to intersect with something, for example:
   
   • names in UPPERCASE, usually they can only intersect with other macro names,
   • names with a prefix (the name of your project, namespace, something else unique), intersection with other names will be possible with very little probability, but it will be a little more difficult for people to use such macros outside of your project.
4. Macros can do something you don't suspect

   Actually, this is the problem of choosing a name for the macro. Let's say we take the same example that is given in the answer by the link:
   

   #define begin() x = 0
   #define end() x = 17
   ... a few thousand lines of stuff here ... 
   void dostuff()
   {
       int x = 7;
       begin();
       ... more code using x ... 
       printf("x=%d\n", x);
       end();
   }
   

   There are clearly chosen names, which are misleading. If the macros were called set0toX () and set17toX () or something like that, problems could be avoided.
   Solutions to the problem:
   
   • competently name macros,
   • replace macros with functions,
   • Do not use macros that implicitly change anything.

• do not require debugging (inside there is simply no need to set a breakpoint)
• have no side effects when deployed (everything is wrapped in brackets)
• do not conflict with names elsewhere (this type of names is selected that are unlikely to be used by anyone else)
• do not change anything implicitly (the name accurately reflects what the macro does, and all work with the surrounding code, if possible, is carried out only through the parameters and the "return value")

Safe method call

#define prefix_safeCall(value, object, method) ((object) ? ((object)->method) : (value))
#define prefix_safeCallVoid(object, method) ((object) ? ((void)((object)->method)) : ((void)(0)))

#define prefix_safeCall(defaultValue, objectPointer, methodWithArguments) ((objectPointer) ? ((objectPointer)->methodWithArguments) : (defaultValue))
#define prefix_safeCallVoid(objectPointer, methodWithArguments) ((objectPointer) ? static_cast((objectPointer)->methodWithArguments) : static_cast(0))

prefix_safeCallVoid(getObject(), method());

#define prefix_safeCall(defaultValue, objectPointer, methodWithArguments)\
[&](auto&& ptr) -> decltype(auto)\
{\
    return ptr ? (ptr->methodWithArguments) : (defaultValue);\
}\
(objectPointer)
#define prefix_safeCallVoid(objectPointer, methodWithArguments)\
[&](auto&& ptr)\
{\
    if(ptr)\
        (ptr->methodWithArguments); \
}\
(objectPointer)

#define prefix_safeCallBaseExpression(defaultValue, objectPointer, methodWithArguments)\
((ptr) ? ((ptr)->methodWithArguments) : (defaultValue))
#define prefix_safeCall(defaultValue, objectPointer, methodWithArguments)\
[&](decltype((objectPointer))&& ptr)\
    -> decltype(prefix_safeCallBaseExpression(defaultValue, ptr, methodWithArguments))\
{\
    return prefix_safeCallBaseExpression(defaultValue, ptr, methodWithArguments);\
}\
(objectPointer)
#define prefix_safeCallVoid(objectPointer, methodWithArguments)\
[&](decltype((objectPointer))&& ptr)\
{\
    if (ptr)\
        (ptr->methodWithArguments);\
}\
(objectPointer)

auto somePointer = ...;
if(somePointer)
    somePoiter->callSomeMethod();

auto somePointer = ...;
prefix_safeCallVoid(somePointer, callSomeMethod());

auto somePointer = ...;
auto x = prefix_safeCall(0, somePointer, callSomeMethod());

Unused variables

#define prefix_unused(variable) ((void)variable)

#define prefix_unused1(variable1) static_cast(variable1)
#define prefix_unused2(variable1, variable2) static_cast(variable1), static_cast(variable2)
#define prefix_unused3(variable1, variable2, variable3) static_cast(variable1), static_cast(variable2), static_cast(variable3)
#define prefix_unused4(variable1, variable2, variable3, variable4) static_cast(variable1), static_cast(variable2), static_cast(variable3), static_cast(variable4)
#define prefix_unused5(variable1, variable2, variable3, variable4, variable5) static_cast(variable1), static_cast(variable2), static_cast(variable3), static_cast(variable4), static_cast(variable5)

#define unused2(variable1, variable2)  do {static_cast(variable1); static_cast(variable2);} while(false)

int main()
{
    int a = 0; // неиспользуемая переменная.
    prefix_unused(a);
    return 0;
}

Conversion to string

#define prefix_stringify(something) std::string(#something)

std::cout << prefix_stringify("string\n") << std::endl;

std::cout << prefix_stringify(std::cout << prefix_stringify("string\n") << std::endl;) << std::endl;

std::cout << prefix_stringify(#define prefix_stringify(something) std::string(#something)
std::cout << prefix_stringify("string\n") << std::endl;) << std::endl;

std::cout << prefix_stringify(#define prefix_stringify(something) std::string(#something)\nstd::cout << prefix_stringify("string\n") << std::endl;) << std::endl;

The comma in the macro parameter

#define prefix_singleArgument(...) __VA_ARGS__

#define FOO(type, name) type name
FOO(prefix_singleArgument(std::map), map_var);

Endless cycle

#define forever() for(;;)

#define ever (;;)
for ever { 
   ...
}

int main()
{
    bool keyPressed = false;
    forever()
    {
        ...
        if(keyPressed)
            break;
    }
    return 0;
}

Conclusion