Thanks Ben,

I am using unmanaged C++ in Visual Studio 2005. Could I use such keyword
like ref and value? If yes, could you recommmend some learning resource
please?

regards,
George

Sure!

value class valClass
{
     int X ;
 // NEEDS a constructor
    valClass( int x) { X= x ; }
} ;
typdef array<valClass> ValClassArray ;

ref class refClass
{
    int X ;
   // DOESN'T need a constructor, but helpful
}
typedef array<refClass^>  RefClassArray ;

main()
{
 // valClass

   valClass vc ;
   vc.X = 1 ;
   valClassArray^ vc_array = gcnew valClassArray(3) ;
   for(int i=0; i < 3; i++)
   {
        vc_array[i].X=i ;
   }

  //same as:
   //vc_array[0].X = 0;
   //vc_array[1].X = 1 ;
   //vc_array[2].X = 2;

  //ref Class

   refClass^ rc = gcnew refClass(1) ; //rc->X=1 ;
   refClassArray rf_array^ = gcnew refClassArray(3) ;
  for(int i = 0;  i < 3;  i++)
  {
      rf_array[i] = gcnew refClass(i) ;
  }

  //same as:
   //vc_array[0] = gcnew refClass(0) ;
   //vc_array[1] = gcnew refClass(1) ;
   //vc_array[2] = gcnew refClass(2) ;
} ;

If you study the above code some difference will start to be clear. For
example, one has to create (gcnew) EVERY single element of a ref class
array, while the value class immediately has the storage allocate when you
create the array POINTER. This shows some good advantages to value classes.

void refMethod( refClass^ rc )
{
  rc->X=1 // original rc changed
}

void valMethod( valClass vc )
{
 vc.X=1 // internal vc COPY changed, original vc unchanged!
}

In refMethod, by passing JUST the pointer to rc it has virtually passed all
of the fields of rc (in this case just X). in valMethod by passing vc it
must copy every field of valClass separately and put it on the stack. In
this case it also just has X, but if valClass had a LOT of fields in it ALL
of them would need to be copied and placed on the stack. Thus for classes
with a large amount of required storage space for its variables, the ref
class appraoch is far more efficient since it need only pass a single
address.

Also, in the refMethod case, actions performed on rc are being performed on
the original rc passed in. Those performed on vc by valClass are performed
on a COPY of the orginal vc, and the original vc in unaffected. There are
advantage to both depending on your needs. For example, if you want the
method to update a variable, it should be a ref class variable. If you just
want to use the value of a variable for calculations, then a value class
variable is best. In a sense, a ref class variable has read/write privileges
while a value class variable only had read privilages in terms of access
(assuming the value class variable is not passed in by pointer, in which
case I beleive you can once again manipulate the original). In affect, a
pointer allows modification, the instance itself, used as a parameter to a
method, acts as if it is read-only. And only value class variables can be
passed in by instance (in contrasr to pointer).

The BASIC language makes this VERY clear. There are two ways to pass a
variable to method in that language: byRef and ByVal. bY Ref is equivalent
to passing a variable via its pointer, allowing modification to the
original. By Val copies the variable and manipulates it leaving the original
alone.

Hope that helps a bit! : )

[==Peter==]

In valMethod