Why is the pointer value in the function different to the one passed in as an argument?

Question

I have the following constructor:

MutexWrapper::MutexWrapper(Mutex * pMutex)
{
  DebugPrint("0x%x", pMutex); // displays 0x1f83e54
}

And it gets called in the following function:

void OnReviewBuffer_Callback( void * pUserData )
{
  ReviewBuffer * thePointer = (ReviewBuffer *) pUserData;

  DebugPrint("0x%x", thePointer); // this displays 0x1f83e48

  MutexWrapper theMutexWrapper(thePointer);
}

Unfortunately I can't provide the entire definition of ReviewBuffer - but I hope the below is enough:

class ReviewBuffer  : public StreamConsumer_Base, public Mutex
{
  ...
};

The problem is that when I print out thePointer I get 0x1f83e48, but the value printed from inside the constructor is 0x1f83e54.

Why are the pointer values different - is this something to do with pass by value passing in a copy of the pointer?

Answer 1

Your class ReviewBuffer uses multiple inheritance:

class ReviewBuffer  : public StreamConsumer_Base, public Mutex
{
  ...
};

The internal layout of the class (probably*) looks like this:

Offset 0    class StreamConsumer_Base
            ... contents of that class (12 bytes including alignment: 0x1f83e54 - 0x1f83e48)
Offset 12   class Mutex
            ... contents of that class (unknown size)

(*) probably because nothing in the standard mandates this. This is just the usual way compilers implement it.

When you initially print thePointer, it points to the ReviewBuffer object ie. offset 0 of the class. But when you pass it to your function, the pointer automatically gets adjusted by the compiler to point to the Mutex part of ReviewBuffer. Since that Mutex part is at offset 12, the value of the pointer cannot be the same (think about it: if it was the same, it would not point to a Mutex but to either a ReviewBuffer or a StreamConsumer_Base).

Answer 2

Your non-default constructor MutexWrapper::MutexWrapper takes a Mutex* pointer as an argument. Your function OnReviewBuffer_Callback casts the provided void* pointer to a ReviewBuffer* pointer. The only way you can pass that ReviewBuffer* pointer as an argument to MutexWrapper::MutexWrapper(Mutex*) is if ReviewBuffer is a derived class of Mutex. If ReviewBuffer also inherits from other classes, downcasting a ReviewBuffer* pointer to a Mutex* pointer may result in a pointer with a different address than the original. That is exactly what's going on, based on the latest edit. ReviewBuffer uses multiple inheritance.

Answer 3

In C++ as in Java, pointer are passed by value. Pass-by-reference is a misnomer.

Of course, pointer pointing to the same address variable, it looks like the whole is passed-by-reference, but...isn't.