ArrayFree

Libera um buffer de qualquer array dinâmico e define o tamanho da dimensão zero para 0.

void  ArrayFree(
   void&  array[]      // array
   );

Parâmetros

array[]

[in]  Array dinâmico.

Valor do Retorno

Sem valor de retorno.

Observação

A necessidade de usar a função ArrayFree() pode não aparecer com muita freqüência, considerando que toda a memória utilizada é liberada de uma só vez e o principal trabalho com os arrays compreende o acesso aos buffers dos indicadores. Os tamanhos dos buffers são controlados automaticamente pelo subsistema executivo do terminal.

No caso, é necessário controlar manualmente a memória no ambiente dinâmico complexo da aplicação, a função ArrayFree() permite que os usuários possam liberar a memória ocupada pelo array dinâmico desnecessário de forma direta e imediata.

Exemplo:

#include <Controls\Dialog.mqh>
#include <Controls\Button.mqh>
#include <Controls\Label.mqh>
#include <Controls\ComboBox.mqh>
//--- constantes predefinidas
#define X_START 0
#define Y_START 0
#define X_SIZE 280
#define Y_SIZE 300
//+------------------------------------------------------------------+
//| Uma classe para trabalhar com uma memória                        |
//+------------------------------------------------------------------+
class CMemoryControl : public CAppDialog
  {
private:
   //--- tamanho de array
   int               m_arr_size;
   //--- arrays
   char              m_arr_char[];
   int               m_arr_int[];
   float             m_arr_float[];
   double            m_arr_double[];
   long              m_arr_long[];
   //--- rótulos
   CLabel            m_lbl_memory_physical;
   CLabel            m_lbl_memory_total;
   CLabel            m_lbl_memory_available;
   CLabel            m_lbl_memory_used;
   CLabel            m_lbl_array_size;
   CLabel            m_lbl_array_type;
   CLabel            m_lbl_error;
   CLabel            m_lbl_change_type;
   CLabel            m_lbl_add_size;
   //--- botões
   CButton           m_button_add;
   CButton           m_button_free;
   //--- caixas de combinação
   CComboBox         m_combo_box_step;
   CComboBox         m_combo_box_type;
   //--- valor atual do tipo array da caixa de combinação
   int               m_combo_box_type_value;
 
public:
                     CMemoryControl(void);
                    ~CMemoryControl(void);
   //--- método de criação de objeto de classe
   virtual bool      Create(const long chart,const string name,const int subwin,const int x1,const int y1,const int x2,const int y2);
   //--- manipulador de eventos gráfico
   virtual bool      OnEvent(const int id,const long &lparam,const double &dparam,const string &sparam);
 
protected:
   //--- cria um rótulos
   bool              CreateLabel(CLabel &lbl,const string name,const int x,const int y,const string str,const int font_size,const int clr);
   //--- criar elementos de controle
   bool              CreateButton(CButton &button,const string name,const int x,const int y,const string str,const int font_size,const int clr);
   bool              CreateComboBoxStep(void);
   bool              CreateComboBoxType(void);
   //--- manipuladores de evento
   void              OnClickButtonAdd(void);
   void              OnClickButtonFree(void);
   void              OnChangeComboBoxType(void);
   //--- métodos para trabalhar com o atual array
   void              CurrentArrayFree(void);
   bool              CurrentArrayAdd(void);
  };
//+------------------------------------------------------------------+
//| Liberar memória do atual array                                   |
//+------------------------------------------------------------------+
void CMemoryControl::CurrentArrayFree(void)
  {
//--- restabelecer o tamanho do array
   m_arr_size=0;
//--- liberar o array
   if(m_combo_box_type_value==0)
      ArrayFree(m_arr_char);
   if(m_combo_box_type_value==1)
      ArrayFree(m_arr_int);
   if(m_combo_box_type_value==2)
      ArrayFree(m_arr_float);
   if(m_combo_box_type_value==3)
      ArrayFree(m_arr_double);
   if(m_combo_box_type_value==4)
      ArrayFree(m_arr_long);
  }  
//+------------------------------------------------------------------+
//| Tentativa de adicionar memória para o atual array                |
//+------------------------------------------------------------------+
bool CMemoryControl::CurrentArrayAdd(void)
  {
//--- se o tamanho da memória usada excede o tamanho da memória física, sair
   if(TerminalInfoInteger(TERMINAL_MEMORY_PHYSICAL)/TerminalInfoInteger(TERMINAL_MEMORY_USED)<2)
      return(false);
//--- tentativa para alocar memória de acordo com o atual tipo
   if(m_combo_box_type_value==0 && ArrayResize(m_arr_char,m_arr_size)==-1)
      return(false);
   if(m_combo_box_type_value==1 && ArrayResize(m_arr_int,m_arr_size)==-1)
      return(false);
   if(m_combo_box_type_value==2 && ArrayResize(m_arr_float,m_arr_size)==-1)
      return(false);
   if(m_combo_box_type_value==3 && ArrayResize(m_arr_double,m_arr_size)==-1)
      return(false);
   if(m_combo_box_type_value==4 && ArrayResize(m_arr_long,m_arr_size)==-1)
      return(false);
//--- memória alocada
   return(true);
  }  
//+------------------------------------------------------------------+
//| Manipulação de eventos                                           |
//+------------------------------------------------------------------+
EVENT_MAP_BEGIN(CMemoryControl)
ON_EVENT(ON_CLICK,m_button_add,OnClickButtonAdd)
ON_EVENT(ON_CLICK,m_button_free,OnClickButtonFree)
ON_EVENT(ON_CHANGE,m_combo_box_type,OnChangeComboBoxType)
EVENT_MAP_END(CAppDialog)
//+------------------------------------------------------------------+
//| Construtor                                                      |
//+------------------------------------------------------------------+
CMemoryControl::CMemoryControl(void)
  {
  }
//+------------------------------------------------------------------+
//| Destrutor                                                       |
//+------------------------------------------------------------------+
CMemoryControl::~CMemoryControl(void)
  {
  }
//+------------------------------------------------------------------+
//| Método para criação de objeto de classe                          |
//+------------------------------------------------------------------+
bool CMemoryControl::Create(const long chart,const string name,const int subwin,
                            const int x1,const int y1,const int x2,const int y2)
  {
//--- base criada de objetos de classe
   if(!CAppDialog::Create(chart,name,subwin,x1,y1,x2,y2))
      return(false);
//--- preparar strings para etiquetas
   string str_physical="Memória Física = "+(string)TerminalInfoInteger(TERMINAL_MEMORY_PHYSICAL)+" Mb";
   string str_total="Memória total = "+(string)TerminalInfoInteger(TERMINAL_MEMORY_TOTAL)+" Mb";
   string str_available="Memória disponível = "+(string)TerminalInfoInteger(TERMINAL_MEMORY_AVAILABLE)+" Mb";
   string str_used="Memória usada = "+(string)TerminalInfoInteger(TERMINAL_MEMORY_USED)+" Mb";
//--- cria um rótulos
   if(!CreateLabel(m_lbl_memory_physical,"physical_label",X_START+10,Y_START+5,str_physical,12,clrBlack))
      return(false);
   if(!CreateLabel(m_lbl_memory_total,"total_label",X_START+10,Y_START+30,str_total,12,clrBlack))
      return(false);
   if(!CreateLabel(m_lbl_memory_available,"available_label",X_START+10,Y_START+55,str_available,12,clrBlack))
      return(false);
   if(!CreateLabel(m_lbl_memory_used,"used_label",X_START+10,Y_START+80,str_used,12,clrBlack))
      return(false);
   if(!CreateLabel(m_lbl_array_type,"type_label",X_START+10,Y_START+105,"Array type = double",12,clrBlack))
      return(false);
   if(!CreateLabel(m_lbl_array_size,"size_label",X_START+10,Y_START+130,"Array size = 0",12,clrBlack))
      return(false);
   if(!CreateLabel(m_lbl_error,"error_label",X_START+10,Y_START+155,"",12,clrRed))
      return(false);
   if(!CreateLabel(m_lbl_change_type,"change_type_label",X_START+10,Y_START+185,"Change type",10,clrBlack))
      return(false);
   if(!CreateLabel(m_lbl_add_size,"add_size_label",X_START+10,Y_START+210,"Add to array",10,clrBlack))
      return(false);
//--- create control elements
   if(!CreateButton(m_button_add,"add_button",X_START+15,Y_START+245,"Adicionar",12,clrBlue))
      return(false);
   if(!CreateButton(m_button_free,"free_button",X_START+75,Y_START+245,"Livre",12,clrBlue))
      return(false);
   if(!CreateComboBoxType())
      return(false);
   if(!CreateComboBoxStep())
      return(false);
//--- inicializar a variável
   m_arr_size=0;
//--- sucesso na execução
   return(true);
  }
//+------------------------------------------------------------------+
//| Criar o botão                                                    |
//+------------------------------------------------------------------+
bool CMemoryControl::CreateButton(CButton &button,const string name,const int x,
                                  const int y,const string str,const int font_size,
                                  const int clr)
  {
//--- criar o botão
   if(!button.Create(m_chart_id,name,m_subwin,x,y,x+50,y+20))
      return(false);
//--- texto
   if(!button.Text(str))
      return(false);
//--- tamanho de fonte
   if(!button.FontSize(font_size))
      return(false);
//--- cor de rótulo
   if(!button.Color(clr))
      return(false);
//--- adicionar o botão para os elementos de controle
   if(!Add(button))
      return(false);
//--- sucesso na execução
   return(true);
  }
//+------------------------------------------------------------------+
//| Criar uma caixa de combinação para o tamanho do array            |
//+------------------------------------------------------------------+
bool CMemoryControl::CreateComboBoxStep(void)
  {
//--- criar a caixa de combinação
   if(!m_combo_box_step.Create(m_chart_id,"step_combobox",m_subwin,X_START+100,Y_START+185,X_START+200,Y_START+205))
      return(false);
//--- adicionar elementos para a caixa de combinação
   if(!m_combo_box_step.ItemAdd("100 000",100000))
      return(false);
   if(!m_combo_box_step.ItemAdd("1 000 000",1000000))
      return(false);
   if(!m_combo_box_step.ItemAdd("10 000 000",10000000))
      return(false);
   if(!m_combo_box_step.ItemAdd("100 000 000",100000000))
      return(false);
//--- definir o elemento atual da caixa de combinação
   if(!m_combo_box_step.SelectByValue(1000000))
      return(false);
//--- adicionar a caixa de combinação para controlar elementos
   if(!Add(m_combo_box_step))
      return(false);
//--- sucesso na execução
   return(true);
  }
//+------------------------------------------------------------------+
//| Criar uma caixa de combinação para o tipo de array               |
//+------------------------------------------------------------------+
bool CMemoryControl::CreateComboBoxType(void)
  {
//--- criar a caixa de combinação
   if(!m_combo_box_type.Create(m_chart_id,"type_combobox",m_subwin,X_START+100,Y_START+210,X_START+200,Y_START+230))
      return(false);
//--- adicionar elementos para a caixa de combinação
   if(!m_combo_box_type.ItemAdd("char",0))
      return(false);
   if(!m_combo_box_type.ItemAdd("int",1))
      return(false);
   if(!m_combo_box_type.ItemAdd("float",2))
      return(false);
   if(!m_combo_box_type.ItemAdd("double",3))
      return(false);
   if(!m_combo_box_type.ItemAdd("long",4))
      return(false);
//--- definir o elemento atual da caixa de combinação
   if(!m_combo_box_type.SelectByValue(3))
      return(false);
//--- armazenar o elemento da caixa de combinação atual
   m_combo_box_type_value=3;
//--- adicionar a caixa de combinação para controlar elementos
   if(!Add(m_combo_box_type))
      return(false);
//--- sucesso na execução
   return(true);
  }
//+------------------------------------------------------------------+
//| criar um rótulo                                                  |
//+------------------------------------------------------------------+
bool CMemoryControl::CreateLabel(CLabel &lbl,const string name,const int x,
                                 const int y,const string str,const int font_size,
                                 const int clr)
  {
//--- criar um rótulo
   if(!lbl.Create(m_chart_id,name,m_subwin,x,y,0,0))
      return(false);
//--- texto
   if(!lbl.Text(str))
      return(false);
//--- tamanho de fonte
   if(!lbl.FontSize(font_size))
      return(false);
//--- cor
   if(!lbl.Color(clr))
      return(false);
//--- adicionar a etiqueta para controlar elementos
   if(!Add(lbl))
      return(false);
//--- sucesso
   return(true);
  }
//+------------------------------------------------------------------+
//| Manipulador criando botão de evento "Adicionar"                  |
//+------------------------------------------------------------------+
void CMemoryControl::OnClickButtonAdd(void)
  {
//--- aumentar o tamanho do array
   m_arr_size+=(int)m_combo_box_step.Value();
//--- tentativa de alocar memória para o atual array
   if(CurrentArrayAdd())
     {
      //--- memória alocada, exibir o status atual na tela
      m_lbl_memory_available.Text("Memória disponível = "+(string)TerminalInfoInteger(TERMINAL_MEMORY_AVAILABLE)+" Mb");
      m_lbl_memory_used.Text("Memória usada = "+(string)TerminalInfoInteger(TERMINAL_MEMORY_USED)+" Mb");
      m_lbl_array_size.Text("Tamanho de array = "+IntegerToString(m_arr_size));
      m_lbl_error.Text("");
     }
   else
     {
      //--- falha para alocar memória, exibir a mensagem de erro
      m_lbl_error.Text("Array é muito grande, erro!");
      //--- retornar o tamanho do array anterior
      m_arr_size-=(int)m_combo_box_step.Value();
     }
  }
//+------------------------------------------------------------------+
//| Manipulador criando o botão de evento "Livre"                    |
//+------------------------------------------------------------------+
void CMemoryControl::OnClickButtonFree(void)
  {
//--- liberar memória do atual array
   CurrentArrayFree();
//--- exibir o status atual na tela
   m_lbl_memory_available.Text("Memória disponível = "+(string)TerminalInfoInteger(TERMINAL_MEMORY_AVAILABLE)+" Mb");
   m_lbl_memory_used.Text("Memória usada = "+(string)TerminalInfoInteger(TERMINAL_MEMORY_USED)+" Mb");
   m_lbl_array_size.Text("Tamanho de array = 0");
   m_lbl_error.Text("");
  }
//+------------------------------------------------------------------+
//| Manipulador da caixa de combinação para alterar evento           |
//+------------------------------------------------------------------+
void CMemoryControl::OnChangeComboBoxType(void)
  {
//--- verificar se o tipo de array foi alterado
   if(m_combo_box_type.Value()!=m_combo_box_type_value)
     {
      //--- liberar memória do atual array
      OnClickButtonFree();
      //--- trabalhar com outro tipo de array
      m_combo_box_type_value=(int)m_combo_box_type.Value();
      //--- exibir um novo tipo de array na tela
      if(m_combo_box_type_value==0)
         m_lbl_array_type.Text("Tipo de array = char");
      if(m_combo_box_type_value==1)
         m_lbl_array_type.Text("Tipo de array = int");
      if(m_combo_box_type_value==2)
         m_lbl_array_type.Text("Tipo de array = float");
      if(m_combo_box_type_value==3)
         m_lbl_array_type.Text("Tipo de array = double");
      if(m_combo_box_type_value==4)
         m_lbl_array_type.Text("Tipo de array = long");
     }
  }
//--- objeto de classe CMemoryControl
CMemoryControl ExtDialog;
//+------------------------------------------------------------------+
//| Função de inicialização do Expert                                |
//+------------------------------------------------------------------+
int OnInit()
  {
//--- criar o diálogo
   if(!ExtDialog.Create(0,"MemoryControl",0,X_START,Y_START,X_SIZE,Y_SIZE))
      return(INIT_FAILED);
//--- lançamento
   ExtDialog.Run();
//---
   return(INIT_SUCCEEDED);
  }
//+------------------------------------------------------------------+
//| Função de Desinicialização do Expert                             |
//+------------------------------------------------------------------+
void OnDeinit(const int reason)
  {
//---
   ExtDialog.Destroy(reason);
  }
//+------------------------------------------------------------------+
//| Expert chart event function                                      |
//+------------------------------------------------------------------+
void OnChartEvent(const int id,
                  const long &lparam,
                  const double &dparam,
                  const string &sparam)
  {
   ExtDialog.ChartEvent(id,lparam,dparam,sparam);
  }