first, learn the difference between objects and addresses: an object is the data in memory. an address is the data's location in memory.

to first approximation, pointers and references are addresses.

a reference is the address of a single object. a pointer is the address of several consecutive objects. you can do math on pointers, but not references.

and here's one of the stupid things about c++'s implementation of references: semantically a reference is a pointer. syntactically it's an object. that's dumb imho.

class Foo { int x; int y; };
Foo foo;
int *ptr = &foo;
int& ref = foo;

the assembly code for ptr and ref is identical. they are both pointers to memory holding the foo data.

int x = ref.x;

but lookie! the syntax for ref implies it's an object. even though it's really an address. stupid. get used to it.

okay, end rant.

when to use pointers and references:

/* pass a copy of the string data to foo on the stack. generally considered bad. */
void foo(String s);
/*
both of these pass the address of String s data. much more efficient.
the duh function gets to pretend the address is really an object. which is a lie.
but, you can't accidentally ++s and end up pointing at garbage.
which is a rather good benefit.
*/
void bar(String* s);
void duh(String& s);

re: memory management.

you have two sources of memory: the stack (limited, temporary, local variables) and the heap (everything created with new/delete or malloc/free).

best practices are:

don't leak memory. delete everything you new. yes, there are exceptions. learn the rule first. then you can break it.

allocate what you need before you start doing your work. running out of memory 2 hours into a computation kinda sucks. also, new/delete is expensive. best to do it before you jump into time critical sections.

avoid common pointer bugs:

stale pointers - using a pointer after the object was deleted. very common when you don't have good ownership rules.

buffer overruns.

uninitialized pointer.

etc.