DLL c++ any examples ?

//+------------------------------------------------------------------+
//|                                                      mySMA10.mq4 |
//|                                                 
//|                                                                  |
//+------------------------------------------------------------------+
#property copyright ""
#include <mySMA10.mqh> // include the compiled header file, which itself includes the compiled DLL
#property indicator_chart_window
//+------------------------------------------------------------------+

// Import and declare the DLL, with its parameters defined
#import "mySMA10.dll"
void    GetSMAArray( double Rates[][6],int MaximumRecords, int Periods, double& OutPut[]);
#import

// At the very beginning of the chart, before the MA has
// had enough data to draw itself properly, do not display
int nDrawBeginBar;

// Indicator Buffers
double OutPut[]; // custom indicator pre-defined buffer
extern int Periods = 10; // Default value - can be changed via GUI

//int ExtCountedBars = 0;

//+------------------------------------------------------------------+
//| Custom indicator initialization function                         |
//+------------------------------------------------------------------+
int init()
  {
   SetIndexBuffer( 0, OutPut ); //Binds array variable declared at global level to the custom indicator pre-defined buffer
   
   // Drawing settings
   SetIndexStyle( 0, DRAW_LINE, 0, 1, Red); // Default values - can be changed via GUI
   SetIndexLabel( 0, "My SMA 10" );         // Description shown in the DataWindow and in the tooltip
   
   // Skip drawing at the beginning of a chart
    nDrawBeginBar = Periods;
    SetIndexDrawBegin(0, nDrawBeginBar);
    
   return(0);
  }
  
//+------------------------------------------------------------------+
//| Custom indicator iteration function                              |
//+------------------------------------------------------------------+
int start()
  {
   double Rates[][6];
   int MaximumRecords = ArrayCopyRates( Rates, Symbol(), 0 );
   for( int zz = MaximumRecords-1; zz >= 0; zz-- ) { OutPut[zz] = EMPTY; }
      GetSMAArray( Rates, MaximumRecords, Periods, OutPut );
      
   return(0); 
  
  } // end of int start()
//+------------------------------------------------------------------+

#ifdef __cplusplus
extern "C" {
#endif

#include <windows.h>

BOOL APIENTRY DllMain (HINSTANCE hInst     /* Library instance handle. */ ,
                       DWORD reason        /* Reason this function is being called. */ ,
                       LPVOID reserved     /* Not used. */ )
{
    switch (reason)
    {
      case DLL_PROCESS_ATTACH:
        break;

      case DLL_PROCESS_DETACH:
        break;

      case DLL_THREAD_ATTACH:
        break;

      case DLL_THREAD_DETACH:
        break;
    }

    /* Returns TRUE on success, FALSE on failure */
    return TRUE;
}

#define WIN32_LEAN_AND_MEAN
#define MT4_EXPFUNC __declspec(dllexport)

//+-----------------------------------------------------------------------------------------------------------------------------+
//|                                                            MT4 DATA STRUCT                                                        |
//+-----------------------------------------------------------------------------------------------------------------------------+
#pragma pack(push,1)
struct RateInfo { unsigned int ctm; double open; double low; double high; double close; double vol; };
struct MqlStr   {          int len; char   * string;                                                };
#pragma pack(pop)
//+-----------------------------------------------------------------------------------------------------------------------------+

MT4_EXPFUNC void _stdcall GetSMAArray( RateInfo* Rates, int MaximumRecords, int Period, double Result[] )
{
      for( int ii = 0; ii < MaximumRecords; ii++)
      {
          double Sum = 0.0;
            for( int kk = 0; kk < Period ; kk++ )
            {
                Sum += Rates[MaximumRecords-ii-1-kk].close;
            }
        Result[MaximumRecords-ii-1] = Sum / Period ;
      }
}

#ifdef __cplusplus
}
#endif

//+------------------------------------------------------------------+
//|                                                Recursive SMA.mq4 |
//|        This code comes as is and carries NO WARRANTY whatsoever  |
//|                                           Use at your own risk!  |
//+------------------------------------------------------------------+

#import "sma_rec.dll"
void updateBuffer( double[color=Red]&[/color] Rates[][6], double[color=Red]&[/color] buffer[], int bars, int indicator_counted, int ma_period, double[color=Red]&[/color] internal_calcs[2] );
#import

//+------------------------------------------------------------------+
//|                                                Recursive SMA.mq4 |
//|        This code comes as is and carries NO WARRANTY whatsoever  |
//|                                           Use at your own risk!  |
//+------------------------------------------------------------------+

#include <sma_rec.mqh>              [color=Green]// include the compiled header file, which itself includes the compiled DLL[/color]
#property indicator_chart_window   [color=Green]// indicator will be plotted in main chart window[/color]
#property indicator_buffers 1       [color=Green]// one indicator line to be plotted[/color]
#property indicator_color1 Red      [color=Green]// default plot colour is red - can be changed via GUI[/color]
//+------------------------------------------------------------------+

[color=Green]// Import and declare the DLL, with its parameters defined[/color]
#import "sma_rec.dll"
[color=Green]// history, buffer and internal_calcs are [color=Red]passed by reference[/color], this means the dll will receive pointers to the arrays[/color]
void updateBuffer( double[color=Red]&[/color] Rates[][6], double[color=Red]&[/color] buffer[], int bars, int indicator_counted, int period, double[color=Red]&[/color] internal_calcs[2] );
#import

extern int ma_period = 10;          [color=Green]// default period is 10 - can be changed via GUI[/color]
extern int ma_shift = 0;            [color=Green]// default is no shift - can be changed via GUI              [/color]
 
double buffer[];                    [color=Green]// the indicator buffer - the array the DLL will write to and which will be plotted[/color]
double Rates[][6];                  [color=Green]// this will later point to the complete chart history [/color]
double internal_calcs[2];           [color=Green]// this array will hold the values of the internal calculations of the DLL and will be
                                    // read from and written to by the DLL. The size of the array is set at 2. If needs be,
                                    // the size can be increased to accommodate more complicated calculations within the DLL.[/color]

int init(){ 
   [color=Green]// set up the indicator buffer [/color]
   SetIndexStyle(0, DRAW_LINE); 
   SetIndexShift(0, ma_shift); 
   SetIndexBuffer(0, buffer); 
   SetIndexLabel(0, "Recursive SMA"); 
   IndicatorDigits(Digits);
}

int start(){
   ArrayCopyRates( Rates, NULL, 0 ); 
   updateBuffer( Rates, buffer, Bars, IndicatorCounted(), ma_period, internal_calcs ); 
}

#ifdef __cplusplus
extern "C" {
#endif

#include <windows.h>

BOOL APIENTRY DllMain (HINSTANCE hInst     /* Library instance handle. */ ,
                       DWORD reason        /* Reason this function is being called. */ ,
                       LPVOID reserved     /* Not used. */ )
{
    switch (reason)
    {
      case DLL_PROCESS_ATTACH:
        break;

      case DLL_PROCESS_DETACH:
        break;

      case DLL_THREAD_ATTACH:
        break;

      case DLL_THREAD_DETACH:
        break;
    }

    /* Returns TRUE on success, FALSE on failure */
    return TRUE;
}

#define WIN32_LEAN_AND_MEAN
#define MT4_EXPFUNC __declspec(dllexport)

//+-----------------------------------------------------------------------------------------------------------------------------+
//|                                                            MT4 HISTORY DATA STRUCT                                                        |
//+-----------------------------------------------------------------------------------------------------------------------------+
#pragma pack(push,1)
struct RateInfo { unsigned int ctm; double open; double low; double high; double close; double vol; };
struct MqlStr   {          int len; char   * string;                                                };
#pragma pack(pop)
//+-----------------------------------------------------------------------------------------------------------------------------+

MT4_EXPFUNC void _stdcall updateBuffer( RateInfo[color=Red]*[/color] Rates, double buffer[], int Bars, int IndicatorCounted, int ma_period, double internal_calcs[2] )
{ 
  if ( IndicatorCounted == 0 ) [color=Green]// check if the DLL is being called for the very first time[/color]
  {
    [color=Green]// if so, calculate indicator values from the beginning of the array up to "current" bar - firstly 
    // for buffer[0] to buffer[ma_period - 1] fill the buffer with increasing moving average values up to
    // the desired moving average period i.e. the second bar in buffer array has value of ma_period = 2;  
    // the third bar in buffer array has value of ma_period = 3 etc.[/color]       
    buffer[0] = Rates[0].close;
    buffer[1] = ( Rates[0].close + Rates[1].close ) / 2.0;
    for( int ii = 2 ; ii < ma_period ; ii++ )
    {    
    buffer[ii] = ( ( buffer[ii-1] * ii ) / (ii+1) ) + ( Rates[ii].close/(ii+1) );    
    }
    [color=Green]// secondly, after the initial part of the buffer is filled, the rest of the buffer is filled using a recursive SMA
    // algorithm. If the SMA were calculated by looping over previous bar values there would be ma_period-1 additions
    // and one division operation per loop of a nested loop. This simple recursive algorithm does away with the need 
    // for a nested loop completely and reduces the number of arithmetic operations to four per bar. More importantly,
    // for learning purposes, it will enable code to be shown for passing parameters that hold the state of internal
    // calculations to and from the DLL.[/color]
    for( int ii = ma_period ; ii < Bars - 1 ; ii++ )
    {    
    buffer[ii] = ( buffer[ii-1] - (Rates[ii-ma_period].close/ma_period) ) + ( Rates[ii].close/ma_period );    
    }
    [color=Green]// now return the values of the internal calculations to the internal_calcs array pending the next call to the DLL[/color]
    internal_calcs[0] = (Rates[Bars-1-ma_period].close/ma_period); [color=Green]// the value to be used in the next SMA calculation [/color]
    internal_calcs[1] = Bars - 1;                                  [color=Green]// how many indicator values calculated so far[/color]
    
  } [color=Green]// end of ( IndicatorCounted = 0 ) if statement for first call of the DLL. Once this piece of the code has been run
    // once, on the initial call to the DLL, it will never be run again because the condition IndicatedCounted == 0 will 
    // never be true again.[/color]

  [color=Green]// this next piece of code will be evaluated on the second and all subsequent calls to the DLL because the condition
  // IndicatorCounted > 0 will always be true after the DLL's initial call. Note that the second part of the [color=RoyalBlue]logical AND[/color],
  // namely (Bars - 1) > internal_calcs[1], ensures that the code will only run when a bar has completely formed and a new
  // bar has opened. This is important to ensure that values contained in the internal_calcs array are not overwritten by
  // the constantly changing values of the currently forming bar. Note that, as above, this is a recursive SMA algorithm
  // so there is no loop.[/color]
     
  if ( IndicatorCounted > 0 [color=RoyalBlue]&&[/color] (Bars - 1) > internal_calcs[1] ) [color=Green]// evaluates to TRUE if there is a new bar[/color]
  {     
  buffer[Bars-2] = ( buffer[Bars-3] - internal_calcs[0] ) + ( Rates[Bars-2].close/ma_period ); [color=Green]// calculate new SMA value[/color]
  internal_calcs[0] = (Rates[Bars-1-ma_period].close/ma_period);[color=Green] // update internal_calcs with new value for next SMA calc.[/color]
  internal_calcs[1] = Bars - 1;                                  [color=Green]// update how many indicator values calculated so far [/color]
  } [color=Green]// end of ( IndicatorCounted > 0 && (Bars - 1) > internal_calcs[1]) if statement[/color]
          
} [color=Green]// end of main function call[/color]

#ifdef __cplusplus
}
#endif

 //sma_rec.mqh file begin
#import "sma_rec.dll"
void updateBuffer( double& Rates[], double& buffer[], int bars, int indicator_counted, int ma_period, double& internal_calcs[2] );
#import
//sma_rec.mqh file end
//sma_rec.mq4 file begin
#include <sma_rec.mqh>
#property indicator_chart_window // indicator plotted in main chart window
#property indicator_buffers 1 // one indicator line to be plotted
#property indicator_color1 Red // plot colour is red - change via GUI
//+------------------------------------------------------------------+
// Import and declare the DLL, with its parameters defined
#import "sma_rec.dll"
// history, buffer and internal_calcs are passed by reference, this means the dll
// will receive pointers to the arrays
void updateBuffer(double& Rates[][6], double& buffer[], int bars, int indicator_counted, int period, double& internal_calcs[2] );
#import
extern int ma_period = 10; // default period is 10 - change via GUI
extern int ma_shift = 0; // default is no shift - change via GUI
double buffer[]; // the indicator buffer - the DLL will
// write to this and it will be plotted
double Rates[][6]; // this will later point to the complete
// chart history
double internal_calcs[2]; // this array will hold the values of the
// internal calculations of the DLL and will
// be read from and written to by the DLL.
// The size of the array is set at 2. If
// needs be, the size can be increased to
// accommodate more complicated calculations
// within the DLL.
int init(){
// set up the indicator buffer
SetIndexStyle(0, DRAW_LINE);
SetIndexShift(0, ma_shift);
SetIndexBuffer(0, buffer);
SetIndexLabel(0, "Recursive SMA");
IndicatorDigits(Digits);
}
int start(){
ArrayCopyRates( Rates, NULL, 0 );
updateBuffer( Rates, buffer, Bars, IndicatorCounted(), ma_period, internal_calcs );
//Print(buffer[]);
}
//sma_rec.mq4 file end

//dllmain.cpp:
#include "stdafx.h"
BOOL APIENTRY DllMain( HMODULE hModule,
                       DWORD  ul_reason_for_call,
                       LPVOID lpReserved
                     )
{
    switch (ul_reason_for_call)
    {
    case DLL_PROCESS_ATTACH:
    case DLL_THREAD_ATTACH:
    case DLL_THREAD_DETACH:
    case DLL_PROCESS_DETACH:
        break;
    }
    return TRUE;
}

#include <windows.h>
#include "stdafx.h"
#include <stdio.h>
 
#define WIN32_LEAN_AND_MEAN
#define MT4_EXPFUNC __declspec(dllexport)
//+------------------------------------------------------------------+
//| MT4 HISTORY DATA STRUCT |
//+------------------------------------------------------------------+
#pragma pack(push,1)
struct RateInfo
  {
   __int64           ctm;
   double            open;
   double            low;
   double            high;
   double            close;
   unsigned __int64  vol_tick;
//   int               spread;
//   unsigned __int64  vol_real;
  };
#pragma pack(pop)
//---
struct MqlStr
  {
   int               len;
   char             *string;
  };
static int CompareMqlStr(const void *left,const void *right);
//+------------------------------------------------------------------+
//|  
 EXTERN_C __declspec(dllexport) void __stdcall updateBuffer( RateInfo* Rates, double buffer[],int Bars, int IndicatorCounted, int ma_period, double internal_calcs[2] )
// MT4_EXPFUNC void _stdcall updateBuffer( RateInfo* Rates, double buffer[],int Bars, int IndicatorCounted, int ma_period, double internal_calcs[2] )
{
// check if the DLL is being called for the very first time
if ( IndicatorCounted == 0 )
    {
        // if so, calculate indicator values from the beginning of the array up to
        // "current" bar - firstly for buffer[0] to buffer[ma_period - 1] fill the
        // buffer with increasing moving average values up to the desired moving
        // average period i.e. the second bar in buffer has value of ma_period = 2;
        // the third bar in buffer array has value of ma_period = 3 etc.
        buffer[0] = Rates[0].close;
        buffer[1] = ( Rates[0].close + Rates[1].close ) / 2.0;
        for( int ii = 2 ; ii < ma_period ; ii++ )
            {
            buffer[ii] = ( ( buffer[ii-1] * ii ) / (ii+1) ) + ( Rates[ii].close/(ii+1) );
            }
            // secondly, after the initial part of the buffer is filled, the rest of the
            // buffer is filled using a recursive SMA algorithm. If the SMA were
            // calculated by looping over previous bar values there would be ma_period-1
            // additions and one division operation per loop of a nested loop. This
            // simple recursive algorithm does away with the need for a nested loop
            // completely and reduces the number of arithmetic operations to four per
            // bar. More importantly, for learning purposes, it will enable code to be
            // shown for passing parameters that hold the state of internal calculations
            // to and from the DLL.
        for( int ii = ma_period ; ii < Bars - 1 ; ii++ )
            {
            buffer[ii] = ( buffer[ii-1] - (Rates[ii-ma_period].close/ma_period) ) + ( Rates[ii].close/ma_period );
            }
            // now return the values of the internal calculations to the internal_calcs
            // array pending the next call to the DLL
        internal_calcs[0] = (Rates[Bars-1-ma_period].close/ma_period);
            // the value // to be used in the next SMA calculation
        internal_calcs[1] = Bars - 1; // how many indicator values calculated so far
    } // end of ( IndicatorCounted = 0 ) if statement for first call of the DLL.
 
// Once this piece of the code has been run once, on the initial call to the
// DLL, it will never be run again because the condition IndicatedCounted ==
// 0 will never be true again.
// this next piece of code will be evaluated on the second and all subsequent
// calls to the DLL because the condition IndicatorCounted > 0 will always be
// true after the DLL's initial call. Note that the second part of the
// logical AND, namely (Bars - 1) > internal_calcs[1], ensures that the code
// will only run when a bar has completely formed and a new bar has opened.
// This is important to ensure that values contained in the internal_calcs
// array are not overwritten by the constantly changing values of the
// currently forming bar. Note that, as above, this is a recursive SMA
// algorithm so there is no loop.
if ( IndicatorCounted > 0 && (Bars - 1) > internal_calcs[1] ) // evaluates to TRUE if there is a new bar
    {
    buffer[Bars-2] = ( buffer[Bars-3] - internal_calcs[0] ) + ( Rates[Bars].close/ma_period ); // calculate new SMA value
 
    internal_calcs[0] = (Rates[Bars-1-ma_period].close/ma_period); // update
    // internal_calcs with new value for next SMA calc.
    internal_calcs[1] = Bars - 1; // update how many indicator values calculated so
    // far
    } // end of ( IndicatorCounted > 0 && (Bars - 1) > internal_calcs[1]) if
    // statement
} // end of main function call