Last time, I discussed the ref type.  This time, I'm going to talk about the value type.  This is the CLR type exposed in Managed Extensions by the __value keyword, and available in Whidbey C++ using the context-sensitive keyword value.

What is a value type?  I view value types as a convenient way to lump data together.  This isn't to say it has no member functions - it might well - but the concept is of a chunk of data.  Where you might use a ref type to implement a linked list class, a value type might be the right choice for the nodes in that linked list.

What makes a value type different from a ref type?  Value types can go almost anywhere: on the stack, as members of a ref class, passed to functions, returned from functions, and even on the gc heap.  They are considerably more lightweight than ref types.  However, unlike ref classes, they cannot be inherited from.

Okay, well that sounds simple.  There's one more wrench in the works: there's a special subset of value types called simple value types.  These are value types that don't contain any handles (^) as members.  With this restriction comes a benefit: simple value types can be allocated on the native heap.

Let's look at the code for a value class:

  value class Point{
  private:
    int x,y;
  public:
    Point(int a, int b):x(a), y(b){}
    int GetX(){ return x; }
    int GetY(){ return y; }
    void set(int a, int b){ x=a; y=b; }
  };

This is a good example of a simple value type, because it contains no handle (^) members. 

Value types aren't too complicated, as you can plainly see.  In a future code sample, we'll look at implementing a basic data structure using completely managed code.