Do básico ao intermediário: Array (III)

Introdução

O conteúdo exposto aqui, visa e tem como objetivo, pura e simplesmente a didática. De modo algum deve ser encarado como uma aplicação final, onde o objetivo não seja o estudo dos conceitos aqui mostrados.

No artigo anterior Do básico ao intermediário: Array (II), expliquei o básico sobre como podemos utilizar arrays do tipo dinâmico e estático. A diferença que existe entre um e outro, e quais os principais cuidados devemos tomar, e ficar atentos, quando formos fazer uso de array em nossas aplicações.

Muito bem, o tema aqui, continuará sendo array. Porém o pré-requisito, para entender este artigo, é ter compreendido o artigo anterior. Além é claro, entender como funciona a passagem por valor e a passagem por referência. Todos estes temas foram vistos e demonstrados nos artigos anteriores. Então se você tem alguma dúvida, ou desconhece tais conceitos, por estar chegando agora. Sugiro que você antes de continuar, dê uma estudada nos artigos anteriores. Para conseguir acompanhar o que será explicado aqui.

Como de costume, vamos iniciar um novo tópico, para dar início aos nossos estudos e demonstrações.

Usando arrays em funções e procedimentos

Um dos tópicos que deixa muito iniciante de cabelos em pé, é o uso de arrays como forma de passar valores entre funções e procedimentos. Aqui, vou ser bem sincero, com relação a uma questão envolvendo tal conceito. A forma como o MQL5, lida com este tipo de coisa é anos luz mais simples do que algumas outras linguagens lidam com este mesmo tema. Linguagens como C e C++, quando utilizadas para lidar com este tipo de coisa. São extremamente complexas. Já que no caso do C e C++, NÃO EXISTE de fato um array, como acontece no MQL5. Naquele caso, usamos uma outra estrutura chamada de ponteiro. E o problema com os ponteiros, que os tornam tão complicados e difíceis de dominar, é o fato de que podemos usar uma referência indireta em alguns casos. Isto apesar de dar muito poder de fogo, ao programador, também torna o código muito mais complicado de ser compreendido. Ainda mais quando o programador tem pouco tempo de experiência em codificação, e uso de ponteiro.

No entanto, aqui no MQL5, as coisas são bem mais fáceis de serem assimiladas e compreendidas. Começando pelo fato, de que:

Todo array é SEMPRE passado por referência, seja para uma função, seja para um procedimento.

Não existe a passagem por valor no caso de se usar um array como argumento em uma função ou procedimento, dentro do MQL5.

Bem, mas você pode estar pensando: Cara, mas se todo argumento, que fizer uso de arrays, é passado como referência, seja para uma função, seja para um procedimento. Isto não tornaria o código menos seguro? Na verdade, não, meu caro leitor. Por mais incrível que possa parecer, usar arrays no MQL5 é muito mais seguro que usar outros tipos de variáveis. E digo mais. Usar arrays no MQL5 é muito mais fácil do que utilizar qualquer outro método visto em outras linguagens. Isto por que, no MQL5, você tem controle total do que pode ou não acontecer com um array. Mesmo que ele seja passado sempre por referência, para uma função ou procedimento.

O que garante este nível de segurança e confiabilidade é justamente um maior cuidado por parte do programador. Quando expliquei sobre como podemos fazer uso de passagem por referência, ou passagem por valor. Mostrei os prós e contras de cada abordagem. Mas aqui é bem mais simples. Já que a própria declaração, seja da função, seja do procedimento, deixa isto muito claro e evidente. Existe um segundo detalhe e cuidado a ser tomado. E este se refere ao fato de que:

Todo array declarado como parâmetro de uma função ou procedimento, deverá ser SEMPRE do tipo dinâmico.

Com estes dois conceitos, sendo aplicados. Você conseguirá criar qualquer tipo de implementação no MQL5, que faça uso de arrays. Já que muitas vezes, é mais prático e adequado, computar coisas dentro de funções ou procedimentos. Em invés de colocar código inline. Observação: Para quem desconhece o termo código inline. O mesmo se refere ao fato de que o programador, não utiliza funções ou procedimentos em sua aplicação. Ele começa criando uma serie de rotinas, uma a pós a outra, como se fosse uma grande receita de bolo. Apesar de serem raras as situações em que este tipo de abordagem, de fato é viável de ser feita. Pode acontecer de ela realmente existir. Sendo a única e principal característica deste tipo de código, é a total e completa ausência de funções ou procedimentos na implementação feita.

Ok, mas vamos voltar a nossa questão, que é justamente como utilizar arrays como parâmetros em funções e procedimentos. Apesar da aparente simplicidade envolvida aqui, você, meu caro leitor, não deve diminuir a guarda imaginando que tudo é muito simples e sem graça. Onde não existe perigo para erros de programação. Pois de fato, existem alguns detalhes, que somente são melhor entendidos, quando colocamos as coisas na prática. Na teoria é tudo muito lindo e magnifico. Sendo necessário entender e conhecer alguns pouco conceitos. Porém na prática o bicho as vezes costuma pegar e dar umas belas dentadas, antes de que consigamos derrotá-lo. Então vamos começar a ver como de fato as coisas se dão na prática. Começando com o código visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const char Infos[]  = {2, 3, 3, 5, 8};
07. 
08.     Print("Based on the values:");
09.     ArrayPrint(Infos);
10.     PrintFormat("There are %d possibilities.", Possibilities(Infos));
11. }
12. //+------------------------------------------------------------------+
13. ushort Possibilities(const uchar &arg[])
14. {
15.     ushort info = 0;
16. 
17.     for (uchar c = 0; c < arg.Size(); c++)
18.         info = (c ? info * arg[c] : arg[c]);
19. 
20.     return info;
21. }
22. //+------------------------------------------------------------------+

Código 01

Ao executar este código 01, você irá ver o que é mostrado na imagem logo abaixo.

Imagem 01

Isto que você está vendo na imagem 01, poderia ser gerado de diversas formas diferentes. A maneira como foi feita, usando o código 01, é apenas para fins didáticos. Já que o objetivo aqui é justamente explicar o que está acontecendo ali, para mostrar como podemos transferir um array para dentro de uma função ou procedimento.

Muito bem, então vamos entender o que está ocorrendo aqui. Lembrando que irei dar destaque somente as partes, que considero como ainda não explicadas em nenhum dos artigos anteriores. Então vamos aos destaques. Começando com a linha seis. Apesar de estarmos usando um array estático ali. Isto está sendo feito, apenas para agilizar o código. Poderíamos usar um array dinâmico ali, e nada iria mudar no que estaria sendo feito. O objetivo de fato, é passar os valores para dentro da função da linha treze. Sendo assim qualquer coisa que venha a ocorrer, antes da linha 10, vista no código 01, não afeta como as coisas irão ocorrer na passagem do array. Desde é claro, tenhamos declarado a função como mostrado na linha treze.

Agora preste atenção, ao que será explicado aqui meu caro leitor. Vimos nos artigos anteriores que um array, quando declarado como constante, precisa OBRIGATORIAMENTE ser iniciado na própria declaração. Isto para evitar erros frente ao compilador. Porém observe esta linha treze, com bastante cuidado. Note que ali, estamos declarando um array como constante. No entanto, apesar disto, o compilador cria o executável. Por que aqui podemos declarar as coisas assim. Mas se tentarmos fazer isto na linha seis, não irá funcionar? O motivo é que aqui, na linha treze e diferente da linha seis, o array está sendo declarado, não como variável, mas sim como um parâmetro. E como foi dito mais no início deste tópico. Todo array precisa ser passado como referência. E é justamente isto que está ocorrendo aqui.

Um detalhe, que talvez, alguns de vocês, que estão iniciando na programação podem ficar imaginando. E de maneira completamente equivocada. O array declarado na linha treze, NÃO ESTÁ sendo declarado como constante por conta do array da linha seis. Uma coisa nada tem a ver com a outra. Você pode inclusive declarar e inicializar o array da linha seis como sendo totalmente dinâmico. Porém isto não suprime o que estará sendo declarado na linha treze. Visto que o proposto é totalmente diferente.

Existe um outro detalhe, neste código 01 que ao meu ver merece ser destacado novamente aqui. Apesar de já ter sido falado em outro momento. A questão em si, está relacionada com o valor de teste na linha 17. Ali estamos usando arg.Size(). Porém isto é permitido e perfeitamente aceito. Já que o resultado é o mesmo que se fosse utilizado a função ArraySize. De qualquer forma, o teste seria feito da mesma maneira em qualquer um dos casos. Deixo como lição de casa, experimentar usar a função ArraySize, no lugar de arg.Size(), a fim de entender melhor como seria implementado o código na prática.

Legal, acredito, que este primeiro contato, tenha sido relativamente agradável e bem prazeroso. Lhe dando uma ideia de como deveríamos implementar o código, a fim de passar um array, seja para uma função, como foi o caso, seja para um procedimento. O que não mudaria em nada a forma de trabalhar e declarar o array como parâmetro neste caso específico. Somente o objetivo poderia ser diferente.

Esta foi a parte fácil. Então podemos partir para algo um pouco mais complicado. Porém para que você possa estudar com calma cada tópico. Vamos complicar as coisas em um novo tópico.

Modificando o array de maneira remota

Uma das possibilidades de uso, que tornam o uso de arrays em funções e procedimentos um tanto quanto complicados, é justamente o de podemos mudar o conteúdo de um array de maneira remota. Ou seja, você envia um array, para uma função ou procedimento. E o mesmo será modificado naquela função ou procedimento. Este tipo de coisa, pode gerar problemas bem confusos e complexos de serem resolvido. Mas como podemos, e em muitos casos faremos este tipo de coisa. É de extrema importância que você venha a entender muito bem, como isto ocorre. Mas principalmente por que isto ocorre.

Diferente de valores discretos, como tipos char, int, long, double e afins. Normalmente as linguagens de programação NÃO nos permite retornar arrays. Salvo casos especiais que a própria linguagem implementa de alguma forma. Como é o caso de strings no MQL5. Foi mostrado em artigos anteriores que uma string, é na verdade um array especial. Sendo assim, este é um dos poucos casos, onde podemos retornar um array de uma função no MQL5. Isto já nos tira o risco, e possíveis problemas que poderiam surgir, em certas implementações que precisamos as vezes fazer. Onde de fato existe a necessidade de retornar um array modificado.

Mas antes de falarmos mais sobre isto. Já que é algo realmente bem complicado de entender em códigos reais. Precisamos entender como outras linguagens lidam com este problema. No caso do C e C++, ele simplesmente joga isto nas mãos do programador. Já que nestas duas linguagens, temos tanto a possibilidade de modificar o array, como também temos a possibilidade de retornar um array completamente novo. Mas não se iluda com isto, pois como arrays não são tratados no C e C++, como são tratados aqui no MQL5. Você não fica menos sujeito a erros. Mas fica consideravelmente mais exposto a erros ainda mais complicados de serem resolvidos. Por isto C e C++ é tão mais complicado de dominar. Já outras linguagens como Python e JavaScript, simplesmente ignoram a existência de tipos convencionais de dados. Criando assim seus próprios métodos para que possamos retornar arrays, ou mesmo modifica-los. Sendo algo bem menos comum de ser feito, do que em outras linguagens. Tornando assim um pouco mais simples, efetuar certos tipos de fatoração. No entanto, o objetivo aqui é falar de MQL5.

Assim sendo, vamos começar com algo que seja o mais simples quanto for possível mostrar. Então vamos fazer uso do que foi o código 01, só que mudando um pequeno detalhe no mesmo. Assim sendo, surge o que é visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char Infos[]  = {2, 3, 3, 5, 8};
07. 
08.     Print("Based on the values:");
09.     ArrayPrint(Infos);
10.     PrintFormat("There are %d possibilities.\nValue after call:", Possibilities(Infos));
11.     ArrayPrint(Infos);
12. }
13. //+------------------------------------------------------------------+
14. ushort Possibilities(uchar &arg[])
15. {
16.     ushort info = 0;
17. 
18.     for (uchar c = 0; c < arg.Size(); c++)
19.         info = (c ? info * arg[c] : arg[c]);
20. 
21.     arg[0] += 2;
22. 
23.     return info;
24. }
25. //+------------------------------------------------------------------+

Código 02

Ao executarmos este código 02, teremos o seguinte resultado visto logo abaixo.

Imagem 02

Note que nesta imagem 02, estou marcando dois valores na mesma. Isto justamente para lhe chamar a atenção, para algo que está ocorrendo aqui. Note que a diferença entre este código 02 e o código 01, é justamente o fato de que agora a linha declaração do parâmetro recebido pela função da linha 14, NÃO É MAIS DO TIPO CONSTANTE. Sendo assim, a passagem por referência que sempre ocorre em arrays, torna possível que venhamos a usar a linha 21. Onde modificamos o valor de um dos elementos pertencentes ao array declarado lá na linha seis. Como aqui estamos trabalhando de forma didática e voltada para explicar certos conceitos que podem ser aplicados ao MQL5. Está mudança que está sendo feita é bem fácil de ser notada. No entanto, em códigos reais, ela pode estar bem profunda. E muitas vezes tão entremeada nas entranhas do código. Que em alguns momentos dá vontade de desistir e começar a codificar tudo do zero novamente. Tamanho o grau de complexidade que pode estar sendo criado.

Por isto meu caro leitor, peço a você, que está começando a estudar programação. Ou que tem pouca experiência no assunto. Que procure praticar bastante estes conceitos que estamos vendo aqui. Somente a prática é que irá lhe dar a experiência necessárias para conseguir lidar com os problemas que, com toda a certeza irão surgir.

Muito bem, este código 02, é de fato o tipo mais simples que existe. Sendo de certa maneira algo quase que banal. Porém a coisa começa a complicar à medida que vamos nos aprofundando ainda mais no assunto. Assim sendo, vamos ver um outro exemplo. Só que desta vez um pouco mais complicado. Este é mostrado logo na sequência.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char Infos[];
07.     
08.     ArrayResize(Infos, 7);   
09.     ZeroMemory(Infos);
10. 
11.     Infos[0] = 2;
12.     Infos[1] = 3;
13.     Infos[2] = 3;
14.     Infos[3] = 5;
15.     Infos[4] = 8;
16. 
17.     Print("Based on the values:");
18.     ArrayPrint(Infos);
19.     PrintFormat("There are %d possibilities.\nValue after call:", Possibilities(Infos));
20.     ArrayPrint(Infos);
21. 
22.     ArrayFree(Infos);
23. }
24. //+------------------------------------------------------------------+
25. ushort Possibilities(uchar &arg[])
26. {
27.     ushort info = 0;
28. 
29.     for (uchar c = 0; c < arg.Size(); c++)
30.         info = (c ? (arg[c] ? info * arg[c] : info) : arg[c]);
31. 
32.     arg[arg.Size() - 1] = 9;
33. 
34.     return info;
35. }
36. //+------------------------------------------------------------------+

Código 03

Certo, aqui temos no código 03, algo um pouco mais complicado. Mas não é mais complicado devido a linha 30. Esta linha continua sendo muito simples de ser compreendida. O código 03 é mais complicado, justamente por conta de que na linha seis estamos declarando um array puramente dinâmico. E aqui é onde as coisas começam a complicar de verdade. Apesar deste código 03, ainda ser um código que ao meu ver, pode ser completa e perfeitamente compreendido por um iniciante que venha estudando o material mostrado aqui nos artigos. Isto dando um passo de cada vez. E entre estes passos esteja praticando o que vem sendo mostrado. Mas vamos ver o resultado da execução deste código 03. Ele é mostrado na imagem logo abaixo.

Imagem 03

Novamente estou dando destaque a alguma informação presente na imagem. Esta informação que está sendo destacada é muito importante ser devidamente compreendida. Então vamos entender o que ocorreu aqui. Como na linha oito, estamos dizendo que o array terá sete elementos. E que nas linhas onze até a quinze estamos inicializando alguns destes elementos. Podemos ver que na linha 18, o conteúdo presente no array, contém alguns zeros. O que é normal, devido justamente ao fato de que na linha nove, estamos limpando a memória onde o array foi alocado. Justamente por conta destes zeros, é que foi necessário adicionar um operador ternário extra, na linha 30. Caso contrário, o resultado da função seria igual a zero. Porém este não é o ponto de interesse neste caso. O ponto de interesse é justamente a linha 32. Note que ali estamos, dizendo que iremos atribuir um valor a um dado elemento. No caso o último elemento presente no array.

Mas por que estou fazendo isto, e nesta sequência de demonstrações? O motivo é que existe uma forma de se trabalhar com arrays, aqui no MQL5. Que nos permite fazer algo, que naturalmente não é possível ser feito aqui. Isto sem que você, meu caro leitor, compreenda certos conceitos relacionados ao uso de arrays. Ao mesmo tempo você também, sem notar, irá começar a ver certas coisas acontecerem aqui, que tornarão, algumas outras coisas muito mais naturais, quando forem vistas em breve.

Perfeito. Agora já temos uma boa dose de complexidade já adicionada ao nosso sistema. Porém, ainda podemos deixar as coisas ainda mais divertidas. Se bem que por mim, o artigo terminaria aqui. Isto para que você meu caro leitor, pudesse praticar o que já foi mostrado até este ponto. E, diga-se de passagem, já é bastante coisa e muitas delas bastante complicadas de serem entendidas assim logo de início. Mas vamos fazer um último esforço. A fim de visualizar algo que pode ser interessante, e que tem tudo a ver com o que está sendo mostrado aqui. Mas como é algo bem mais complicado. Vamos a um novo tópico.

Inicialização remota

Neste momento, peço a você, meu caro e estimado leitor e amigo, o seguinte: Pare, estude o que foi visto até este momento. Quando já estiver compreendido de maneira total e sem que fique dúvidas ou conflitos em sua cabeça, a fim de conseguir entender os códigos anteriores. Aí sim, venha para o que será visto neste tópico. Pois aqui a coisa fica começa a ficar confusa demais, para ser encarada sem uma preparação adequada.

O que foi mostrado até agora, nos mostra que podemos enviar dados usando arrays. Depois disto, vimos que podemos modificar dados em um array, dentro de uma outra função, ou procedimento. Este tipo de coisa precisa ser feito com muita atenção. Principalmente quando você estiver decidido a criar uma aplicação mais elaborada. Logo em seguida, vimos que podemos trabalhar com o array buscando ajustar onde iremos modificar o valor. Agora chegou a hora de fazer uma outra coisa. E está é mostrada no código visto logo na sequência.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char Infos[];
07.     
08.     InitArray(Infos);
09. 
10.     Print("Based on the values:");
11.     ArrayPrint(Infos);
12.     PrintFormat("There are %d possibilities.\nValue after call:", Possibilities(Infos));
13.     ArrayPrint(Infos);
14. 
15.     ArrayFree(Infos);
16. }
17. //+------------------------------------------------------------------+
18. void InitArray(uchar &arg[])
19. {
20.     ArrayResize(arg, 7);    
21.     ZeroMemory(arg);
22. 
23.     arg[0] = 2;
24.     arg[1] = 3;
25.     arg[2] = 3;
26.     arg[3] = 5;
27.     arg[4] = 8;
28. }
29. //+------------------------------------------------------------------+
30. ushort Possibilities(uchar &arg[])
31. {
32.     ushort info = 0;
33. 
34.     for (uchar c = 0; c < arg.Size(); c++)
35.         info = (c ? (arg[c] ? info * arg[c] : info) : arg[c]);
36. 
37.     arg[arg.Size() - 1] = 9;
38. 
39.     return info;
40. }
41. //+------------------------------------------------------------------+

Código 04

E aí está meu caro leitor, este é o clímax do que será visto neste artigo. Porém não se deixe enganar pela aparente simplicidades deste código 04. Pois apesar de o resultado dele ser o que vemos logo abaixo, ele é muito mais complicado do que parece.

Imagem 04

Note que o resultado é o mesmo que foi visto na imagem 03. Idêntico em todos os sentidos. Mas aqui neste código 04, estou mostrando algo, de maneira simples, que pode se tornar muito, mas muito complicado mesmo. Porém se for devidamente implementado e de forma adequada, conseguirá suprimir diversas coisas. Principalmente coisas que alguns que se dizem programadores experientes, afirmam que NÃO DÁ para ser feito no MQL5. Isto de forma pura e sem utilizar nenhum outro recurso que não esteja disponível no MQL5.

Fiz estas mudanças aos poucos, justamente para que você consiga acompanhar o que está sendo feito aqui. Mas apesar de você olhando para este código 04, poder até imaginar que ele é uma simples mudança do que está sendo feito pelo código 03. Este código 04, bem lá no fundo, está mostrando que podemos fazer algo que não é possível sem que tenhamos certos conceitos muito bem assimilados. Um destes conceitos, e é o que estamos explorando aqui no código 04, é justamente o fato de que todo array é passado por referência. E quando fazemos isto, usando conceitos vistos em outros artigos anteriores. Podemos de fato fazer algo que muitos diriam não ser possível ser feito. Ou seja, inicializar, ou mesmo modificar arrays, fora do local onde eles estão sendo declarados. Podemos levar isto a um caso um pouco mais extremo. Isto sem mudar o nível de dificuldade demonstrado até aqui. Para explicar isto, vamos mudar novamente o código 04, mas de uma forma bem sutil. Como você pode ver no código logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     char Infos[];
07.     
08.     if (ArraySize(Infos))
09.     {
10.         Print("Based on the values:");
11.         ArrayPrint(Infos);
12.     }else
13.         Print("Array has not been initialized yet.");
14.     PrintFormat("There are %d possibilities.\nValue after call:", Possibilities(Infos));
15.     ArrayPrint(Infos);
16. 
17.     ArrayFree(Infos);
18. }
19. //+------------------------------------------------------------------+
20. void InitArray(uchar &arg[])
21. {
22.     const char init [] = {2, 3, 3, 5, 8};
23. 
24.     ArrayCopy(arg, init);
25. }
26. //+------------------------------------------------------------------+
27. ushort Possibilities(uchar &arg[])
28. {
29.     ushort info = 0;
30. 
31.     InitArray(arg);
32. 
33.     for (uchar c = 0; c < arg.Size(); c++)
34.         info = (c ? (arg[c] ? info * arg[c] : info) : arg[c]);
35. 
36.     ArrayResize(arg, arg.Size() + 1);
37.     arg[arg.Size() - 1] = 9;
38. 
39.     return info;
40. }
41. //+------------------------------------------------------------------+

Código 05

Ao executar este código 05, você irá se deparar com a imagem mostrada logo abaixo.

Imagem 05

Pois bem, agora sim, você pode estar se perguntando: Como isto é possível? Este tipo de coisa não faz o menor sentido. Mas aqui estou apenas brincando um pouco com o mesmo código visto desde o começo deste artigo, meu caro leitor. Não existe de forma alguma motivo para pânico, ou desespero. O detalhe é que diferente do que muitos normalmente fazem. Aqui estamos levando ao limite, justamente conceitos que são perfeitamente exploráveis dentro do MQL5. Apesar de que, nestes últimos códigos visto aqui, estamos levando a coisa um pouco além do que muitos conseguem perceber. Isto por que, eles não utilizam o conceito envolvido na implementação. Eles apenas copiam e colam códigos, ou trechos de código, sem de fato entender por que aquele código funciona. E não é este meu desejo. Quero que você meu caro leitor de fato consiga compreender os conceitos envolvidos. Se você conseguir atingir este objetivo. Já terá valido muito a pena escrever estes artigos e demonstrar tais coisas.

Muito bem, como não quero ainda, e principalmente neste artigo entrar em detalhes de uma outra coisa, que já pode ser feita. Apenas por conta destes dois últimos códigos terem sido mostrados. Vou dedicar o restante deste artigo para explicar em detalhes, um destes código. No caso, vamos focar no código 05. Já que o código 04 é um pouco mais simples que este código 05.

Ok. Então vamos ver como este código 05 trabalha. Primeiro temos na linha seis, a declaração de um array puramente dinâmico. Este deverá ser alocado em algum momento. Isto para que possamos usar a memória como um deposito de informações.

Supondo que não saibamos se o array da linha seis, foi ou não inicializado. Usamos a linha oito, para testar se existe ou não algum elemento no array. Lembre-se: É um array puramente dinâmico. Se você o inicializar diretamente na linha seis, esta linha oito irá perceber isto. Ou mesmo, se ele for inicializado entre a linha seis e a linha oito. Ainda assim esta linha oito irá perceber este fato. No entanto, se a inicialização for feita, exatamente na linha seis, onde o array está sendo declarado. Você terá outros problemas aqui. Experimente fazer isto, para compreender que tipo de problema irá surgir. Isto irá lhe ajudar praticar e pegar experiência com arrays.

De qualquer modo, se existir algum elemento no array, teremos as linhas dez e onze sendo executadas. Mostrando justamente que elementos existem no array. Caso ele não tenha sido iniciado, teremos a mensagem vista na linha treze sendo mostrada no terminal.

Agora vem a parte que torna as coisas bem interessantes. Isto acontece justamente devido a linha 14. Que irá chamar a função na linha 27. Veja que até este momento o array AINDA NÃO FOI INICIALIZADO. Ele somente será inicializado, no momento que a linha 31 for executada. Isto por que, é justamente nesta linha a responsável por chamar o procedimento visto na linha 20. Este procedimento, irá na linha 24, inicializar o array dinâmico criado na linha seis. Agora veja que para fazer isto, estaremos usando um array estático do tipo ROM, que é visto na linha 22. Sei que isto parece ser muito confuso e difícil de entender. Mas se você olhar a função ArrayCopy da biblioteca padrão irá entender por que isto funciona. Mas basicamente o que esta função faz é copiar um array para dentro de outro array. E existe uma enorme quantidade de vezes em que isto pode ser utilizado em aplicações reais. Logo depois de ter feito isto, iremos entrar no laço da linha 33. Neste momento fazemos os cálculos a fim de ter uma resposta para retornar a linha 14.

Porém antes de retornarmos a linha 14, usamos a linha 36 para adicionar um novo elemento ao array que está declarado na linha seis, mas que foi inicializado na linha 24. E é esta a parte interessante. Pois se você, não inicializar o array, devido ao fato de ter removido a linha 31 do código. Esta função Possibilities, irá retornar um valor igual ao presente na linha 29. Isto por que o laço da linha 33 não será executado. Porém quando você for olhar o que existe no array, que foi declarado na linha seis. Irá ver que existirá um elemento no array. E este elemento tem o valor que está sendo indicado na linha 37.

De fato, é necessário experimentar isto na prática para conseguir entender o que foi dito aqui. Então como venho mencionando. Pratique e use o conteúdo presente no anexo, a fim de entender melhor como as coisas funcionam.

Considerações finais

Neste artigo, as coisas ficaram bem mais divertidas do que estava sendo feito nos artigos anteriores. Isto porque, aqui começamos a explorar novas possibilidades de uso, de conceitos que vem sendo explicados desde o primeiro artigo. Sei que para quem chegou aqui assim, sem ter visto os demais artigos. Muito do que foi mostrado pode parecer extremamente complexo e confuso. Porém, quem vem praticando e estudando cada um dos artigos, sabe muito bem, que este conteúdo é bem interessante. E o mesmo abre diversas possibilidades, entre elas uma que foi vista de maneira bem superficial em outro artigo mais antigo.

No entanto, no próximo artigo, iremos fazer com que algo visto antes se torne tão comum no seu dia a dia, que você nem irá perceber que está se tornando um programador melhor do que muitos por aí. Já que tendo os conceitos corretos, e sabendo como os aplicar, você irá se libertar das amarras que muitos continuam aprisionados. Justamente por não entender os conceitos ligados a programação. Mas apenas por copiar e colar código. Então divirta-se com os arquivos no anexo, e nos vemos no próximo artigo.