Managed C++/CLI

property int Data;

property int Data
{
   int get()
   {
       return data;
   }
   void set(int d)
   {
       data = d;
   }
}

property String^ S

// default constructor, initializes data members to non null values
Foo() 
{
   Data = 0;
   S = "default";
}
 
// constructor with 2 parameters, initializes data members to non null values
Foo(int d, String^ in)
{
   Data = d;
   S = in;
}
...
property int Data;
property String^ S;

#include "stdafx.h"

using namespace System;

// managed class with explicity copy constructor and assignment operator
ref class Foo
{
public:
   Foo() {} // default constructor

   // constructor takes a single parameter
   // intialize value data member via direct access or through property
   Foo(int d)
   {
      Value = d; // (3)
      //value = d; // (4)
   }
   // copy constructor
   // could declare parameter const but then you can't use Value property
   Foo(Foo^ b) //: value(b->value) Initializer presumably doesn't work for the same reasons
   {
      //Value = b->Value; // (1)
      value = b->value; // (2)
      //value = b->Value; // Presumably doesn't work for the same reasons
   }

   // trivial property declaration, in theory creates the same code as the explicit below
   property int Value;

   // explicit property declaration
   /*property int Value
   {
      int get()
      {
         return value;
      }
      void set(int v)
      {
         value = v;
      }
   }*/

// note: value must be public for Block B to work.
// Public or private doesn't affect the following results.

//private:
   int value;
};


int main (array<System::String ^> ^)
{
    // **************************************************************************
    // The following results are based on using the default constructor
    // and setting the value member after construction
    // Define 'works' to mean the copy constructor properly initializes the
    // value data member of the new Foo object to be equal to the value in the passed argument
    /* If the copy constructor uses (1) instead of (2):
     * TRIVIAL PROPERTY DECLARED: Block A works, Block B doesn't work
     * EXPLICIT PROPERTY DECLARED: Block A works, Block B works

     * If the copy constructor uses (2) instead of (1):
     * TRIVIAL PROPERTY DECLARED: Block A doesn't work, Block B works
     * EXPLICIT PROPERTY DECLARED: Block A works, Block B works
     *****************************************************************************/

   // *****************************************************************************
   // The following results are based on using the single parameter constructor
   // to set the value data member
   /* If the single parameter constructor uses (4) instead of (3):
    * TRIVIAL PROPERTY DECLARED: Block A doesn't work, Block B works
    *    The single parameter constructor doesn't properly assign value
    *    Copy constructor may not be working either
    * EXPLICIT PROPERTY DECLARED: Block A works, Block B works
    
    * If the single parameter constructor uses (3) instead of (4):
    * TRIVIAL PROPERTY DECLARED: Block A doesn't work, Block B doesn't work
          Block A the single parameter constructor works but the copy constructor doesn't
          Block B the single parameter constructor doesn't work and the copy constructor may not either
    * EXPLICIT PROPERTY DECLARED: Block A works, Block B works
    ********************************************************************************/

   // Block A
   //Foo b(5); // uncomment this line and comment out the next 2 for the second set of results
   Foo b;
   b.Value = 5;
   Foo^ c = gcnew Foo(%b);

   Console::WriteLine("After creating c using the copy constructor passing b:");
   Console::WriteLine("b.Value: " + b.Value + " c->Value: " + c->Value);
   c->Value = 10;
   Console::WriteLine("\nAfter updating c->Value via property:");
   Console::WriteLine("b.Value: " + b.Value + " c->Value: " + c->Value);

   Console::WriteLine();

   // Block B
   //Foo d(5); // uncomment this line and comment out the next 2 for the second set of results
   Foo d;
   d.value = 5;
   Foo^ e = gcnew Foo(%d);

   Console::WriteLine("\nAfter creating e using the copy constructor passing d:");
   Console::WriteLine("d.Value: " + d.value + " e->Value: " + e->value);
   e->value = 10;
   Console::WriteLine("\nAfter updating e->Value via property:");
   Console::WriteLine("d.Value: " + d.value + " e->Value: " + e->value);
}

dynamic_cast<TImage^>(Form1->Components[k])->Picture->LoadFromFile("T1.bmp");

iddqd515 wrote:

So is there anything a handle can do that an interior pointer can't?