I am a newbie to cpp, am a bit confused with this whole pass by ref vs
pass by pointer stuff...
The biggest difference between passing by pointer and passing by
reference is syntax (and there are a lot of consequences of that [e.g.
you can have NULL pointers, references mix well with primitive types
in templates, etc.], it is by no means a small difference). But from
the point of view of *what* you are actually passing around; these two
functions are for the most part identical:
void function1 (Object *ptr) {
// here we assume ptr != NULL.
ptr->SomeMethod();
}
void function2 (Object &ref) {
ptr.SomeMethod();
}
void whatever () {
Object *obj = new Object();
function1(obj); // <-- same exact end effect as...
function2(*obj); // <-- ...this line
}
There is another major difference between pointers and references,
although it comes into play more when declaring pointer and reference
variables rather than passing things to functions. A pointer is an
actual variable. It occupies some memory, and it holds the address, in
memory, of something else. A reference, on the other hand, is just
that -- a reference. A reference does not necessarily occupy any
physical memory -- it is more of an alias for something. Also, a
reference can't exist unless it refers to something:
int a;
int *a_ptr = &a;
int &a_ref = a;
That is all OK; but the following:
int *b_ptr; // <--- this is OK
int &b_ref; // <--- this is not, it does not make sense.
.... contains an error. You have to initialize 'b_ref'. A reference
can't exist unless it refers to something. A pointer, on the other
hand, is just a variable like any other.
I am creating a new object on the heap using new. Now if I pass this
pointer to any function, is it okay to assume that the function can
delete that pointer, or should I delete the pointer in my function
only.
In general, you should try to only delete objects in the "opposite" of
the code that you create them in. For example, if you have a function
like this:
void function () {
Object *obj = new Object;
// do something with obj
delete obj;
}
There you instantiate Object at the beginning of the function, so it
makes sense to delete the object at the end of the function. Or
something like this:
void function () {
Object *obj1 = new Object;
if (...) {
Object *obj2 = new Object;
...
delete obj2;
}
delete obj1;
}
There it makes sense to delete the Objects just before they go out of
the scope they were created in. Likewise, if you allocate objects in
the constructor of some class, it makes sense to delete them in the
destructor:
class Something {
public:
Something () {
m_object = new Object;
}
~Something () {
delete m_object;
}
private:
Object *m_object;
};
Or if you have some initialization function that allocates objects, it
makes sense to destroy those objects in the corresponding "cleanup"
function.
The reason I say it's "good" to do it this way in general is just
because, at least when you are just starting to get the hang of it,
following simple sets of rules like that makes it easier to keep track
of what is going on. In reality, there are many, many different idioms
you can follow for object creation and destruction. Really you need to
keep a few things in mind:
1) How long does this object need to live? When will it be safe to
destroy it?
2) Things must happen in a known order -- do not construct code that
has the risk of using an object before it is instantiated, or after it
has been destroyed. Take care not to construct code that destroys an
object that has already been destroyed. One good rule of thumb here is
to try to always clean things up in the reverse order that you have
created them (you don't *have* to do it this way but it makes sense in
many situations), for example:
ObjectA *obja = new ObjectA();
ObjectB *objb = new ObjectB(obja); // maybe this depends on obja
initialize_something(obja, objb); // a made up function
// do stuff; then cleanup in reverse:
cleanup_something(obja, objb);
delete objb;
delete obja;
3) Documentation and comments helps a lot; for example:
// note: do not delete Objects that you pass to this
// function, it will take care of deleting them for
// you!
void function1 (Object *obj);
// note: the caller may safely delete the object
// passed to this function immediately after calling
// it.
void function2 (Object *obj);
4) At any point, if you no longer have a reference or pointer to an
Object you've created with new() available anywhere in your program,
then you have no way of destroying that object. This will cause a
memory leak. For example:
Object *ptr;
ptr = new Object(); // <-- instance #1
ptr = new Object(); // <-- new instance, uh oh!
delete ptr;
In that example you have no way of destroying the first instance you
created. For a brief moment you stored it's address in 'ptr', but then
you stored something else in 'ptr' immediately afterwards, and now you
have no way of accessing that first object again.
That's not a complete list of things to think about. Other people here
may give you some more insight. But that's what I can think of off the
top of my head, and also I have not had any coffee yet to day so I'm
only running at 25% power output or so.
Of course, keeping your code exception-safe can require a lot more
logic than the examples I gave above, but I am trying to keep it
simple.
And also I read somewhere it is always good to pass objects by
reference, is it true for objects on the stack or for objects created
with new as well..
Well, like most things that are "always good", it's not necessarily
always good. More accurately: in many cases it is far more convenient
to pass objects by reference because the syntax can be easier to deal
with, the code can be slightly more readable, less documentation may
be required because some ambiguity is removed, and a few other
reasons.
For example, syntax and readability:
// less readable, and uglier syntax
int add2elems (const vector<int> *a) {
if (a->size() < 2)
return 0;
else
return (*a)[0] + (*a)[1];
}
// more readable, and prettier syntax
int add2elems (const vector<int> &a) {
if (a.size() < 2)
return 0;
else
return a[0] + a[1]; // <-- esp. here
}
Here is an example of it being somewhat self-documenting:
// note: DO NOT PASS NULL or this will crash!
void dosomething (Data *data);
// as opposed to:
void dosomething (Data &data);
Where the case with the reference does not require the comment about
not passing NULL; you probably won't pass a NULL reference (I don't
even know if these exist).
Hope that helps; that's at least what I can think of right now. If you
have any more specific questions, they may be easier to answer. You
can also try reading through the results here:
http://www.google.com/search?hl=en&q=pointer+reference+difference&btnG=Google+Search
Some of those results are more valuable than others; you may want to
take things that you read (especially on public internet forums) with
a slight grain of salt and verify by experimenting on your own. Also
if you ask here, you will eventually get the correct answer from
somebody or other, so feel free to post any more questions you
have!
Good luck,
Jason
