Re: pointer vs non-pointer
On Tue, 22 Apr 2008 09:18:10 GMT, Your Name <none@none.none> wrote:
Does limited scope means the object is only used in the same function
"Scope" generally means "within the inner-most open/close braces." For
example, in C++ you can even do things like:
void func(int x, int z)
{
if (x == 5)
{
int y = x + 1;
y *= z;
}
y += 14; // (Compile error because "y" is out of scope here!)
}
So, if I want to return an object created in a function I better use
dynamic creation?
MyCar myfunction(){
MyCar mycar;
return mycar;
} // this is return by value
// this is more expensive as it copy whole value and return value
MyCar* myfunction(){
MyCar* mycar = new MyCar();
return mycar;
} // this is return by reference(pointer)
// less expensive as it only return 4 byte = pointer.
Also for a collection of object like a LinkedList object, since it's
very expensive to return by value, i must use return by
reference(pointer):
LinkedList* myfunction(){
LinkedList* list = new LinkedList();
return list;
} // this is return by reference(pointer)
// less expensive as it only return 4 byte = pointer.
// instead of return by value to copy all element in the List
I most case, I would perfer to use the static object creation:
MyCar mycar;
since I don't need to worry about delete / free object after creation.
When are the times I must use dynamic creation ( create a pointer )?
One obvious case is when you actually want to create certain things
"dynamically." Suppose you're writing a game. When the user clicks the
mouse button, you want to make a gun fire a bullet. You don't know at
compile time how many times he might press that button. You would need
to create a new "MyBullet" object every time he presses the button, and
probably "delete" the objects when they hit something, or when they are
far enough away that you can't see them any more. You can't do that in
a clean way without creating the objects dynamically.
A common trick in the old days of C (and even before) was to place a
limit on the number of objects that could be created. That's the
reason, when you play "Galaga," that you can't fire more than two
bullets at a time. If you enforece a limit like this, then you can
declare your objects statically:
MyBullet bullets[2];
And then when the user presses the "fire" button, you have to check and
make sure that at least one of the bullets has already scrolled off the
top of the screen. If it has, you don't actually create anything, you
just move the bullet that's hiding just off the screen back to the tip
of the gun and start it going upward again.
There are certainly benefits to static allocation - speed being a major
one. There's also no possiblity of memory leaks. There are lots of
reasons to use dynamic allocation, but it's never absolutely necessary.
It just makes sense in a lot of cases. It's usually kind of a balancing
act.
In that case, if I used static object allocation, will it crash my
program? Will something like null pointer exception happens? as the
object get destroy automatically after function exit:
void myfunction(){
MyCar mycar = new MyCar();
// mycar is used by other function also after function returns
mycar.AddEventListener();
// even myfunction returns,
// but mycar still need to listen for events
}
Pat