Question

I’m having a problem with a class like this:

class Sprite {
    ...
        bool checkCollision(Sprite &spr);
    ...
};

So, if I have that class, I can do this:

ball.checkCollision(bar1);

But if I change the class to this:

class Sprite {
    ...
        bool checkCollision(Sprite* spr);
    ...
};

I have to do this:

ball.checkCollision(&bar1);

So, what’s the difference?? It’s better a way instead other?

Thank you.

Answer 1

In both cases you are actually passing the address of bar1 (and you’re not copying the value), since both pointers (Sprite *) and references (Sprite &) have reference semantics, in the first case explicit (you have to explicitly dereference the pointer to manipulate the pointed object, and you have to explicitly pass the address of the object to a pointer parameter), in the second case implicit (when you manipulate a reference it’s as if you’re manipulating the object itself, so they have value syntax, and the caller’s code doesn’t explicitly pass a pointer using the & operator).

So, the big difference between pointers and references is on what you can do on the pointer/reference variable: pointer variables themselves can be modified, so they may be changed to point to something else, can be NULLed, incremented, decremented, etc, so there’s a strong separation between activities on the pointer (that you access directly with the variable name) and on the object that it points to (that you access with the * operator – or, if you want to access to the members, with the -> shortcut).

References, instead, aim to be just an alias to the object they point to, and do not allow changes to the reference itself: you initialize them with the object they refer to, and then they act as if they were such object for their whole life.

In general, in C++ references are preferred over pointers, for the motivations I said and for some other that you can find in the appropriate section of C++ FAQ.

In terms of performance, they should be the same, because a reference is actually a pointer in disguise; still, there may be some corner case in which the compiler may optimize more when the code uses a reference instead of a pointer, because references are guaranteed not to change the address they hide (i.e., from the beginning to the end of their life they always point to the same object), so in some strange case you may gain something in performance using references, but, again, the point of using references is about good programming style and readability, not performance.