A destructor is executed when you no longer need an object. To provide a destructor for a class, add a member function that has the same name as the class but is preceded by a tilde character (~).

ref class MyClass
{
public:
    MyClass();      // constructor
    ~MyClass();     // destructor
};

You can signal that you no longer need an object by calling delete on a handle to the object.

// Create an Account
Account ^acc = gcnew Account();

// Use the Account

// We no longer need the Account
delete acc;

At this point in the code the destructor is called; thus, you know exactly where and when the object has ceased to operate.

Here are three points you should note about destructors:

Finalizers are called when the garbage collector finally reclaims the object’s memory. You will need a finalizer if you have unmanaged resources, such as pointers to unmanaged classes, file handles, window handles, graphic device contexts, and so on. If you don’t have any of those—and you’ll only tend to do that when you are working with unmanaged code—you probably don’t need a finalizer.

A finalizer is a member function that has the same name as the class but is preceded by an exclamation mark (!).

ref class MyClass
{
public:
    MyClass();      // constructor
    !MyClass();     // finalizer
};

You can see that finalizers obey the same rules as destructors; they have the same name as the class and don’t have a return type or take arguments.

In this exercise, you will see how to create and use the finalizer and destructor for a class.

MyClass::~MyClass()
{
    // Free up managed resources: this will be done anyway by the runtime
    // Now call the finalizer to free unmanaged resources
    this->!MyClass()
}

It might seem rather tedious to have to create objects by using gcnew and then call delete on the handles when you have finished using them. After all, wasn’t the idea of garbage collection supposed to be that you didn’t have to keep track of your objects when you finished with them?

It is important not to confuse the concept of an object tidying up after itself with the runtime reclaiming the object’s memory; the two are independent of one another. You might want to say what an object does to tidy up when you have finished with it but not really care when the garbage collector decides to reclaim its memory. In this case, you would implement a destructor, which you can then call by using delete.

MyClass m("m3");
m.DoSomething();

{
    MyClass m("m3");
    m.DoSomething();
}  // Destructor for m is called here

void DoLongOperation()
{
    SetCursorToHourglass();

    // Lots of complex code...

    SetCursorToArrow();
}

ref class BusyCursorHelper
{
public:
    BusyCursorHelper { SetCursorToHourglass(); }
    ~BusyCursorHelper { SetCursorToArrow(); }
};

void DoLongOperation()
{
    BusyCursorHelper bch();

    // Lots of complex code...
}

A copy constructor is a special kind of constructor function that takes an object of the same type as its argument. In other words, you can create an object as a copy of another one. In this section you’ll see how to write and use a copy constructor, but you’ll also learn about two other important concepts: dereferencing and tracking references.

Let’s start by analyzing what happens in the following piece of code:

ref class MyClass
{
   int value;
   String ^str;
public:
   MyClass(int v, String ^s) : value(v), str(s) {}
   int getValue() { return value; }
   String ^getString() { return str; }
};

int main(array<System::String ^> ^args)
{
    Console::WriteLine("Copy Construction");

   MyClass ^one = gcnew MyClass(3, "abc");
   MyClass ^two = one;

   Console::WriteLine("Value: {0}, str: {1}", two->getValue(), two->getString());

    return 0;
}

If you run this code, it prints out Value: 3, str: abc. The handle one points to a new MyClass object created through gcnew. The handle two is simply a copy of one; in other words, it points to the same object as one. Copying a handle doesn’t copy the object to which it points. And, if you modify the value member of two, the value for one will be changed, as well, because they are referring to the same object.

Suppose, though, that we did want to make two a copy of one. In that case, we would provide a copy constructor for the class, which would look like this:

MyClass(const MyClass %other)
{
    value = other.value;
    str = other.str;
}

The constructor takes another MyClass object and copies its members. The value is an int, so a copy of the value is made. The str member is a handle to a string, but because strings are immutable, it doesn’t matter that we’re pointing to the same one.

But, look more closely at the declaration of the argument: What is a const MyClass%? The percent (%) symbol introduces what is called a tracking reference. A handle lets you refer to an object indirectly, and you use the -> operator to access members. A tracking reference is really an alias, another name for a variable. Consider this code fragment:

int i = 5;
int %ri = i;   // ri is a tracking reference

Printing out ri prints “5”, because ri and i refer to the same variable. In many ways references are safer than handles because it is possible to have a handle that hasn’t been assigned, but it is difficult to create an uninitialized reference.

You can have references to built-in types, to managed objects, and to handles. When you have a tracking reference to a managed object, the runtime ensures that it always refers to the right location in memory, even if the garbage collector moves things around.

So, we now know that the copy constructor takes a tracking reference to an object rather than a handle. The reference is marked as const because it lets us make copies of constant MyClass objects, which the compiler otherwise would not allow.

The other construct that we need to cover is dereferencing. Here’s another code fragment:

MyClass ^m = gcnew MyClass();
MyClass %rm = *m;

The first line creates a MyClass object by using gcnew and returns a handle to it. The second line returns a reference to m by using the dereference operator, “*” (the asterisk character). You can read *m as “what m points to.”

However, this still hasn’t created a copy: m and rm are still referring to the same object in memory. But, what about this code?

MyClass mm = *m;

Here, mm is a MyClass with stack semantics, and the code is saying “create me a new object, mm, as a copy of the one to which m is pointing.” It is at this point that the copy constructor is invoked.

This exercise shows you how to implement a copy constructor for a class.

It is common for objects to be composed of other objects. For example, a Person might have an Address, or a Rectangle might be composed of two Points. Consider the Rectangle as an example. Because the Points are part of the Rectangle, it is reasonable to expect that when a Rectangle object is destroyed, its Points are destroyed, as well. If you declare the objects by using stack semantics, you can easily ensure that this happens.

In this exercise, you will see how to compose objects so that they are destroyed correctly.

You can see from this output that the Point members of the Rectangle are constructed before the Rectangle’s constructor is called. If you think about it, this is quite logical: when initializing itself, the Rectangle might want to use the Points to set some other properties, such as its area or diagonal length. So, it makes sense for the composed objects to be constructed before the constructor for the outer object is executed.

The destructors are called in reverse order, with the Rectangle destructor being called before the destructors for the Points. The Point objects are not destroyed until you can be sure that the Rectangle no longer needs them.

Rectangle r();  // This won't work

ref class Rectangle
{
    Point ^p1;
    Point ^p2;
    ...
};