I can’t seem to post to Herb Sutter’s blog, my comments just never appear and ones I’ve made are gone. Maybe he has me blocked for some mysterious reason. So I thought I’d put my answer to the problems here.
Anyone that wants to write solid C++ should be reading his blog. I suggest subscribing.
So, my answer to GotW 91 is:
#1 – Some extra locking and reference counting will take place. A new small object will be created on the stack. Not much will happen actually. The locking is the greatest concern.
#2 – I don’t believe it matters until threads are introduced. If you call this function via a thread spawning though you want to be sure that you do so by value. Doing it by reference can create a race condition in which you reduce the reference count while the pointer is being used or copied by the other side. When that happens it could be that you’re the last one holding the pointer and then the other side gets to have it’s resource yanked out from under it. This is bad voodoo.
#3 has made me want to come up with a set of smart pointer types that secure and ensure correct ownership semantics. In this case you’d take a pointer (by value) of the kind that specifies how you’ll use it. If only within scope then you’d specify that with type. It’s a pretty tough problem though…at least for me.
The answer to the question is one of three (given the types in the question):
1. Use reference – when in doubt, use a reference rather than pointer. If you don’t need a pointer, don’t use one.
2. Use unique_ptr by value – You intend to steal ownership of the pointer and you want this ownership transfered away from client code immediately.
3. The parameter could be null but you don’t want to steal it. Use a raw pointer (for now at least…if I ever solve the above idea then you may have a smart pointer to use instead)