Thread: Hi there! I need some help with a macro definition thanks

I have no clue what the next bit is doing

You can't recognize a simple function call?

Really? I didn't see any of that in the definition.

Since you haven't shown us the definition of IID_PPV_ARGS_Helper we can't help you with that problem.

We might be able to help you more if you show us how the IID_PPV_ARGS macro function is used.

That's what's got me puzzled John, this is all the author mentions about the helper function. Was confusing to me to see it in the same line as the definition but seemingly rather lacking in description. I'll give an example of where at least one of the things in this definition is used:

Code:

MicroSoft::WRL::ComPtr<ID3D12CommandQueue> mCommandQueue;
D3D12_COMMAND_QUEUE_DESC queueDesc = {};

//fills out some struct variables....

ThrowIfFailed(md3dDevice->CreateCommandQueue(&queueDesc, IID_PPV_ARGS(&mCommandQueue)));

So I can see the IID_PPV_ARGS part gets passed to the function, and the __uuidof part of the definition means the &mCommandQueue argument resolves to the GUID of the COM interface ID3D12CommandQueue. I'm mostly ok with that. I just can't fathom the second part of the definition, seems like there's just no description of what it does. I'll have a look through some source code and see if it's mentioned there but this seems awfully sparse on description but that is exactly how it's presented in the book so far.



Edit: This was quite interesting:
IID_PPV_ARGS_Helper Function | Microsoft Docs

Seems the IID_PPV_ARGS_Helper function isn't even meant to be called directly, MicroSoft recommend just using the IID_PPV_ARGS instead. I think that's why I've struggled so much to understand the macro.

Recall that a "function-like macro" is not a function; it just looks like one.
IID_PPV_ARGS is not "passed" to CreateCommandQueue,
nor is its "output", since it is not a function.
Instead, a macro is just textual replacement.
This is a bit of an unusual macro that is meant to turn one parameter into two parameters (hence the comma).

C/C++ code is compiled in two phases:
1. preprocessing
In which includes, defines, and other preprocessor "directives" are processed and removed.
2. compiling
The resulting program text is compiled, with all the included stuff (possibly thousands of lines), all the defines replaced with their textual replacements, etc.

Consider:

Code:

#include <iostream>
 
#define FUNCLIKE_MACRO(x) f(x), g(x)
 
int f(int x) { return 2 * x; }
int g(int x) { return 3 * x; }
 
void func(int a, int b, int c) {  // needs 3 params
    std::cout << a << ',' << b << ',' << c << '\n';
}
 
int main() {
    func(1, FUNCLIKE_MACRO(2)); // kind of looks like we're only passing 2 params
 
    // the macro textually expands to:
    func(1, f(2), g(2));
    // now we're passing the constant 1, the output of f(2) and the output of g(2)
}

Apparently IID_PPV_ARGS_Helper just returns its input as a void**, except that it ensures that the input (sans pointer levels) derives from IUnknown.

If it helps any, you might want to try applying the stand-alone preprocessor to some sample code to see what it does.

What you want is called cpp for the GCC compiler suite; there is an option in GCC to access it as well, gcc -E. See this MSDN page and this Stack Overflow thread for more details on the Visual Studio equivalent.