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.