// This program illustrates how to write a singleton class (a class that
// can have only one instance) in C++. The trick is to make the default
// constructor, copy constructor and assignment operator all private. A
// static function GetInstance returns the one and only object instance.
//
// If you attempt to compile this program, it will generate errors.
// (See main function below.)
// 
class CSingleton {
public:
   static CSingleton& GetInstance() {
      static CSingleton theInstance; // one and only instance
      return theInstance;
   }

protected:
   // need default ctor for GetInstance.
   // ctor is protected, not private in case you want to derive.
   CSingleton() { }

private:
   CSingleton(const CSingleton& o) { }
   CSingleton& operator=(const CSingleton& o) { }
};
 
main()
{
    // These lines will not compile:
    CSingleton x = CSingleton::GetInstance(); // error: private 
                                              // copy ctor!
    CSingleton y = CSingleton::GetInstance(); // error: private 
                                              // copy ctor!
    x = y;                                    // error: private 
                                              // assignment!
}

// Singleton — list top-level visible windows
//
using System;

sealed class Singleton
{
   private Singleton() { }
   public static readonly Singleton TheInstance = new Singleton();
   public void SayHello() {
      Console.WriteLine("hello,world");
   }
}

class MyApp {
   // global command-line switches

   [STAThread]
   // main entry point
   static int Main(string[] args) {
//    Singleton s = new Singleton(); // error!
      Singleton s = Singleton.TheInstance;
      s.SayHello();
      return 0;
   }
}

// To build:
//
//    cl /LD MyLib.cpp
//
#include <stdio.h>

// This is normally defined in windows.h:
#define CALLBACK __stdcall

// callback function takes array of ints and length
typedef void (CALLBACK* ARRAYCB)(int ar[], int len);

// fwd ref
static void PrintArray(int* ar, int len);

///////////////////
// Simple array test: unmanaged C function receives array, length and
// displays it on console.
//
extern "C" __declspec( dllexport ) void TestArray(int ar[], int len)
{
   // display array on stdout
   printf(" [c++] inside TestArray: ar=");
   PrintArray(ar, len);
}

///////////////////
// Callback test: unmanaged C function receives a callback that takes an
// array and count.
//
extern "C" __declspec( dllexport ) void TestArrayCallback(ARRAYCB cbfn)
{
   // create an array
   int len = 10;
   int* parray = new int[len];
   for (int i=0; i<len; i++) {
      parray[i] = len-i;
   }

   // pass it to callback
   printf(" [c++] inside TestArrayCallback, cbfn=%p, calling it 
      now...\n", cbfn);
   (*cbfn)(parray, len);
}

///////////////////
// Modify array test: unmanaged C function receives an array, modifies
// it, and returns to .NET caller. The array must be passed as a C# ref,
// so it's declared here as a ptr-to-array. The length is also passed as
// ref so it's a ptr-to-int. The function replaces each item in the
// array with its value squared. Its function doesn't alter the size of
// the array, but it could. 
//
extern "C" __declspec( dllexport ) void TestModifyArray(int** pArray, 
   int* pLen)
{
   int len = *pLen;
   int* ar = *pArray;
   
   printf(" [c++] inside TestModifyArray, *pArray=");
   PrintArray(ar, len);
   printf(" [c++] squaring elements...\n");

   // modify array: square each element
   for (int i=0; i<len; i++) {
      ar[i] *= ar[i];
   }
}

//////////////////
// Helper fn to print array on stdout.
//
static void PrintArray(int* ar, int len)
{
   printf("[");
   for (int i=0; i<len; i++) {
      if (i>0)
         printf(",");
      printf("%d", ar[i]);
   }
   printf("], len=%d\n", len);
}

// This program illustrates how to pass integer arrays between C# and
// C++ in various ways, and in particular how to pass an array from C++
// to a C# callback without having the array length collapse to 1. The
// trick is to use MarshalAs with SizeParamIndex to tell the framework
// which callback parameter contains the array size.
//
// To build:
//
//    csc TestArray.cs 
//
using System;
using System.Runtime.InteropServices;

//////////////////
// This class wraps the unmanaged C++ functions in MyLib.dll.
//
class LibWrap {
   [DllImport("MyLib.dll")]
   public static extern void TestArray(int[] ar, int len);

   // callback delegate declaration. SizeParamIndex = 1 tells .NET that
   // the length of the array is in the 1st (2nd from 0-offset) param.
   //
   public delegate void ArrayCB(
      [MarshalAs(UnmanagedType.LPArray, SizeParamIndex=1)] int[] ar, int
         len);

   [DllImport("MyLib.dll")]
   public static extern void TestArrayCallback(ArrayCB cb); 

   [DllImport("MyLib.dll")]
   public static extern void TestModifyArray( ref IntPtr array, ref 
      int len );
}
//////////////////
// App class with Main entry
//
class MyApp {

   // callback function simply displays array contents
   private static void MyCallbackFn(int[] ar, int len) {
      Console.Write(" [c# ] inside MyCallbackFn with array=");
      WriteArray(ar);
   }

   // main entry point
   [STAThread]
   static int Main(string[] args) {

      // create array
      int len = 7;
      int[] array = new int[len];
      for (int i=0; i<len; i++) {
         array[i] = i+1;
      }

      // Run simple array test.
      Console.WriteLine("TEST 1 — Pass array from .NET to C++");
      Console.Write(" [c# ] calling TestArray with array=");
      WriteArray(array);
      LibWrap.TestArray(array, len);

      // Run callback test
      Console.WriteLine("\nTEST 2 — Pass array callback from .NET
                        to C++:");
      Console.WriteLine(" [c# ] calling TestArrayCallback...");
      LibWrap.ArrayCB mycb = new LibWrap.ArrayCB(MyCallbackFn);
      LibWrap.TestArrayCallback(mycb);

      // Run modify array test. This requires copying the array to an
      // InPtr buffer allocated with Marshal.AllocCoTaskMem.
      // 
      Console.WriteLine("\nTEST 3 — Pass modifiable array from .NET 
                        to C++");
      IntPtr buf =
         Marshal.AllocCoTaskMem(Marshal.SizeOf(array[0]) * array.Length);
      Marshal.Copy(array, 0, buf, array.Length );
      Console.Write(" [c# ] calling TestModifyArray with array=");
      WriteArray(array);
      LibWrap.TestModifyArray(ref buf, ref len); // call DLL
      array = new int[len];                  // new array w/returned length 
      Marshal.Copy(buf, array, 0, len);      // copy buffer to array
      Marshal.FreeCoTaskMem(buf);            // free buffer
      Console.Write(" [c# ] TestModifyArray returns array=");
      WriteArray(array);

      return 0;
   }

   // helper to print array on console
   static private void WriteArray(int[] ar)
   {
      Console.Write("[");
      for (int i=0; i<ar.Length; i++) {
         if (i>0) 
            Console.Write(",");
         Console.Write(ar[i]);
      }
      Console.WriteLine("], len={0}", ar.Length);
   }

################################################################
# MSDN Magazine — February 2003
# If this code works, it was written by Paul DiLascia.
# If not, I don't know who wrote it.
# Compiles with Visual Studio .NET on Windows XP. Tab size=3.
#
# To build, type "NMAKE" in a console window. Make sure your LIB and
# INCLUDE variables are set up as per the Visual Studio vsvars32.bat.
#

all: MyLib.dll TestArray.exe

MyLib.dll: MyLib.cpp
   cl /LD MyLib.cpp

TestArray.exe: MyLib.dll TestArray.cs
   csc TestArray.cs