When to use pointers in c++

Question

I've recently started to get the hang off using c++. The only thing i'm having difficulty understanding is the use of pointers. I understand that pointers basically "point" to memory addresses of that variable. When should you start using pointers in your variables?
For example:
Without using a pointer i could just do:
myobject hello(1);
However i could also use a pointer to do just the same:
myobject* hello = new myobject(1);
With those 2 examples, you are basically creating a myobject named hello. Is there any difference between the pointer hello and the normal hello?
Last edited by dozerismydogsname (2010-04-30 03:05:10)

Answer 1

dozerismydogsname wrote:Is there any difference between the pointer hello and the normal hello?
The short answer: the object the pointer hello points to is allocated on the
heap, the normal hello is allocated on the stack. That means, after your current
block of code (enclosed in {}) ends, the normal hello will be destroyed while
the other one needs to be deleted by you using delete. If you don't delete it,
you'll get what is called a memory leak.
Whenever possible, you should use stack variables. When you need to use
pointers, you should really think about using std::auto_ptr or boost::shared_ptr
to prevent memory leaks as much as possible.
But I think your real question is this:
dozerismydogsname wrote:When should you start using pointers in your variables?
That question is far more difficult to answer. Usually, you tend to use pointers
if you start passing around arrays:
double sum (int n, const double* const numbers)
double result = 0.;
for (int i=0; i<n; ++i)
result += numbers[i];
return result;
However, this is C-style. In C++ you would try avoiding using pointers directly
by using encapsulating objects like such:
#include <vector>
double sum (const std::vector<double> numbers)
double result = 0.;
for (int i=0; i<numbers.size(); ++i)
result += numbers[i];
return result;
Which again saves you from thinking about who has to delete the pointer after
it's been used.
Often you want to use pointers to avoid copying large structures, but here you
typically can use references as well.
The only reasonable place in C++ I can currently think of to use pointers are
function pointers and places where you want to share structures (class or struct
instances) among several objects and want to be able to dynamically exchange
them. Again, you should use boost::shared_ptr here to avoid memory leaks. An
example:
class ReduceStrategy
public:
virtual double reduce (const double& a, const double& b) = 0;
protected:
ReduceStrategy ();
class SumStrategy : public ReduceStrategy
public:
SumStrategy ()
: ReduceStrategy() {}
virtual double reduce (const double& a, const double& b)
return a + b;
class SubtractStrategy [...]
class Reducer
public:
Reducer (boost::shared_ptr<ReduceStrategy> strategy)
: _strategy(strategy) {}
boost::shared_ptr<ReduceStrategy> strategy(new SumStrategy);
std::vector<Reducer> reducers;
for (int i=0; i<1000; ++i)
reducers.append(Reducer(strategy));
In this example, all 1000 Reducer instances share a pointer to the very same
ReduceStrategy object. If that object were very large now, you'd save a hell lot
of memory. Also, it would be possible to exchange the strategy for one, several
or all of the Reducer instances.
Wow, this text has become much longer than I originally intended^^ Hope it helps
at least a little.
Have fun learning C++!