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.