Re: pointer vs non-pointer

<worlman385@yahoo.com> ha scritto nel messaggio
news:oa9r04p183q3b64i4337ngdidreeq2lht7@4ax.com...


In this case an instance of MyCar class is created on the stack (the
instance name is 'mycar').
It is an "automatic" variable, and when the instance ('mycar') goes out of
scope, its destructor is called.


In this case the instance of MyCar class is created on the heap, and the
destructor must be called by the programmer.
If you don't call the destructor, you have a memory (or resource) leak here.

If you want to share the instance in several places and in different scopes,
you may consider creating the object on the heap (using 'new'), and passing
the pointer to this instance in each place you want to use the object.

If your object has a shared ownership semantic, you may consider wrapping it
using boost:: or tr1:: shared_ptr template. shared_ptr is a "smart pointer",
which manages reference count for the pointed object. When the reference
count of the object becomes zero, it means that there's no more "interest"
in the object, and shared_ptr deletes the pointed instance. shared_ptr can
help simplify a lot your code.

Note that you can also use shared_ptr with STL container classes like
std::vector, i.e. you can build an array of shared_ptr smart pointers,
something like this:

 // Smart Pointer to MyCar
 typedef tr1 or boost ::shared_ptr< MyCar > MyCarSP;

 // Array of smart pointers
 typedef std::vector< MyCarSP > ListOfMyCars;


If you want to use the object only in this function you can build the
instance on the stack, making it an automatic variable.
The above code is fine.


In this case you should "export" the pointer to MyCar instance outside the
function.
Note that the above code causes memory leaks, because nobody deletes mycar.
Also note that C++ is different from Java and C# (where you have a garbage
collector): there's no garbage collector in C++.
Every object allocated on the heap in C++ must be deleted (explicitly using
'delete' keyword, or implicitly using a smart pointer like shared_ptr).

You may modify the above code something like this:

 MyCar * myfunction()
 {
    MyCar * myCar = new MyCar();
    myCar->AddEventListener();

    // Pass the pointer to instance to outer context
    return myCar;
 }


You're right.

And note that you may also use shared_ptr as a smart pointer, if you don't
want to worry about delete/free.

Giovanni