When to use pointers, and when not to use them

Question

I'm currently doing my first real project in C++ and so, fairly new to pointers. I know what they are and have read some basic usage rules. Probably not enough since I still do not really understand when to use them, and when not.

The problem is that most places just mention that most people either overuse them or underuse them. My question is, when to use them, and when not?.

Currently, in many cases i'm asking myself, should I use a pointer here or just pass the variable itself to the function.

For instance, I know that you can send a pointer to a function so the function can actually alter the variable itself instead of a copy of it. But when you just need to get some information of the object once (for instance the method needs a getValue() something), are pointers usefull in that case?

I would love to see either reactions but also links that might be helpfull. Since it is my first time using C++ I do not yet have a good C++ book (was thinking about buying one if I keep on using c++ which I probably will).

Answer 1

Use it whenever you are dealing with allocated memory or passing arguments by reference to a method; I don't think there is a rule for not using pointers.

Answer 2

1) I tend to use member variables scoped with the class. They are constructed in the initializer of the class, and I don't need to worry about pointers.

2) You can pass by reference to a function, and not worry about passing pointers. This effectively will pass a pointer to the method / function that can be used as if you passed the class, but without the overhead of copying the class itself.

3) If I need to control the lifetime of an object that is independent of my main application architecture's classes... then I will use an auto_ptr from the STL to automatically handle the pointer's destruction when no one longer references it. Check it out - it's the way to go.

Answer 3

Generally, when you can use references instead of pointers it is a good idea. A reference must have a target (no NULL pointer violations), they allow the same semantics as pointers when being passed as arguments to a function, and they are generally nicer to use for beginners (or those not coming from a C background).

Pointers are required when you want to do dynamic allocation of memory; when you need to deal with an unknown amount of things that will be later specified. In this case the interface to access memory is through new and delete which deal in pointers.

Answer 4

From the c++ faq:

Use references when you can, and pointers when you have to.

http://www.parashift.com/c++-faq-lite/references.html#faq-8.6

Answer 5

For the do's and dont's of C++:

Effective C++ and More Effective C++ by Scott Meyers.

For pointers (and references):

• use pass by value if the type fits into 4 Bytes and don't want to have it changed after the return of the call.
• use pass by reference to const if the type is larger and you don't want to have it changed after the return of the call.
• use pass by reference if the parameter can't be NULL
• use a pointer otherwise.

---

dont't use raw pointers if you don't need to. Most of the time, a smart pointer (see Boost) is the better option.

Answer 6

My philosophy is to always pass by value, unless you need to modify the variable passed or copying the object is expensive. In both these cases, consider using a reference instead of a pointer first: if you don't need to change which object you're referencing, nor do you need a possible extremal value (NULL pointer), you can use a reference.

Don't forget about iterators either.

Answer 7

All good answers above. Additionally, if you are performing some processor-intensive work, it's important to realize that dereferencing a pointer will likely be a cache miss on your processor. It's a good idea to keep your data accessible with minimal pointer dereferences.

Answer 8

1. Class attribute: pointer
2. Variables declared in methods: no pointers, so we avoid memory leaks.

In this way, prevent memory leaks and controlle attribute's consistency.

Salu2.

Answer 9

My rules of thumb:

1. Always pass function parameters as const references,
2. unless they are built-in types, in which case they are copied (and const/non-const becomes a question of style as the caller isn't affected) or
3. unless they are meant to be changed inside the function so that the changes reflect at the caller's, in which case they are passed by non-const reference or
4. unless the function should be callable even if callers don't have an object to pass, then they are passed as pointers, so that callers can pass in NULL pointers instead (apply #1 and #3 to decide whether to pass per const T* or per T*)

Streams must always be passed around as non-const references.