Difference between pointer-to-pointer vs reference

Question

I have a bit of COM code that uses interface pointers. The original author of the code implemented functions that return an interface pointer like this:

HRESULT Query ( IN BSTR sQuery, OUT IEnumWbemClassObject* &pEnumerator ); // (1)

instead of the traditional

HRESULT Query ( IN BSTR sQuery, OUT IEnumWbemClassObject** ppEnumerator ); // (2)

The function (1) is called like this:

hRes = Query ( sQuery, pEnumerator ); // (3)

which definitely looks wrong but it works fine. I'm not sure if I'm just picking up this line because the out parameter is not a pointer to the output variable or because there's something wrong with this approach.

Is there an advantage to using a reference-to-pointer instead of a pointer-to-pointer for out parameters?

Answer 1

The advantages are the same as any use of references instead of pointers:

• simplicity
• references can't be null, so assigning to a reference in Query won't cause an access violation

Note the original description was in error: IEnumWbemClassObject* & is a reference to a pointer, not a pointer to a reference.

Answer 2

It's better to think of Type& foo* as a reference to a pointer rather than the other way around, as it no longer implies that you can modify the reference through the pointer and other such C++-breaking ideas. It also makes that function call a little easier to believe in as it's just like passing anything else in by reference, no dereferencing or special symbols are required.

Answer 3

Its because pointer and reference are represented identically in normal c++ implementation (this is implementation detail however, not part of the standart. also its reference to pointer, not pointer to reference, you are not allowed to create pointer to reference at all.

Answer 4

The first example is that of a reference to a pointer, ie. a reference to a type IEnumWbemClassObject*:

HRESULT Query ( IN BSTR sQuery, OUT IEnumWbemClassObject* &pEnumerator );

Therefore if pEnumerator is declared as a IEnumWbemClassObject* (which I'm assuming it is), you don't need to explicitly pass the address of pEnumerator to the function or dereference the variable inside the function in order to change where pEnumerator points (which would otherwise be required with an argument of IEnumWbemClassObject**).

A reference to a pointer has the same behaviour as a reference to any other type, just think of the above example as being a "reference to a pointer" and not a "pointer to a reference." There's no such thing as a pointer to a reference.