The ref type

There are two major CLR types that we expose in Whidbey: ref and value.
I'll talk about ref types here, and about value types later.

So, what is a ref type?   This is the same type that was exposed
in Managed Extensions as __gc. 
It is implicitly inherited from the CLR base type System::Object and
has access to all of the features in that type.  Let's take a look
at a simple ref type:

  ref class R{

public:

R(int x):i(x){} //constructor

int get(){ return i; } //member
function

private:

int i; //int member

};

That's fairly simple.  In definition, the ref type isn't all that different
from a regular old C++ class.  In fact, for some of your existing C++ classes,
you may be able to slap a ref on the
front and make it into a ref type.

Ref types are allocated on the GC
heap.  In C++, when you wanted to put something on the native heap, you made
a pointer to it (using the * indirection)
and newed it thusly:

  class N{}; //native
class

N* n = new N; //allocate N on the native heap

Apply the same concepts to ref types, except you use the "handle" indirection ^ ,
instead of the pointer, and instead of using the operator new you
use gcnew, like this:

  ref class R{}; //ref type

R^ r = gcnew R; //allocate R on the gc heap 

This is one of the many simple additions to the C++ language that makes working with
CLR types simple, easy, and straightforward.  It looks a lot like code you're
used to seeing.