Question

I was coding up a C++ class today, and I wrote a function that took an argument as a reference rather than a pointer, something I rarely ever do. I’ve always passed by pointers. So I was about to change it back, and then I realized – I have no idea if I should, or if it even matters.

So I turn to you guys. I have three ways of passing parameters about:

//1: By pointer
Object* foo(Object* bar) {…}

//2: By reference
Object& foo(Object& bar) {…}

//3: By value (just for completeness)
Object foo(Object bar) {…}

Assuming #3’s out for performance reasons (yes, I know compilers have gotten pretty good at this, but still), the other two are more or less equivalent.

So: What’s the "best" method? Pointers? References? Some combination of the two? Or does it even matter? Technical reasons are the best, but stylistic reasons are just as good.

Update: I’ve accepted YeenFei’s answer, since it deals with the difference that clinched it for me (even if I then pointedly ignored his advice – I like having NULL as an option…). But everyone made good points – especially GMan (in the comments), and Nemo, in the answer dealing with performance and passing by value. If you’re here for answers, check them all!

Answer 1

I would suggest to pass your argument by reference if it is expected to be valid. This would be a by-design optimization and save you from defensive programming.

Reference cannot be null while pointer can.
If you are dealing with pointer, you will need to verify whether given pointer is valid (non-null) regardless it is in raw form or wrapped in managed container (shared_ptr), before using them.