Do básico ao intermediário: Array e Strings (II)

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 e Strings (I), demos uma leve introdução sobre strings e arrays. Apesar de que aquele artigo foi praticamente todo focado apenas em falar sobre strings. Tudo que foi visto ali, é somente uma leve e breve introdução sobre o tema. Porém para que possamos vir a falar de outras coisas. Precisamos primeiramente nos aprofundar um pouco mais a respeito do que foi visto naquele artigo anterior. Sendo assim, o pré-requisito para acompanhar e compreender o que será visto neste artigo é justamente ter compreendido o que foi mostrado naquele artigo.

Mas além deste primeiro pré-requisito, existem outros igualmente necessários. Como entender o comando IF e os comandos utilizados em laços. Além de ter alguma noção sobre operadores e variáveis. Todos estes pré-requisitos, serão adequadamente preenchidos, se você estudou os artigos anteriores. Se este não é o seu caso. Procure estudar o que foi visto antes para compreender o que será mostrado aqui.

Muito bem, dadas estas primeiras informações, podemos começar com que será o tema principal deste artigo. Mas para isto vamos a um novo tópico.

Formatação personalizada

Uma das coisas mais bacanas em programar em MQL5, é o fato de que, não precisamos nos preocupar em criar certas coisas. Na verdade, são raros os momentos, em que a biblioteca padrão do MQL5, não nos atende. Mas pode acontecer de ela não atender ao que necessitamos ou queremos fazer. E uma destas coisas é criar uma formatação personalizada para apresentar algum tipo de informação. Seja no terminal, seja em algum objeto gráfico que iremos estar utilizando.

Como nestes primeiros momentos não iremos fazer uso de objetos gráficos. Todo e qualquer trabalho a ser feito, será orientado a utilizar a saída padrão do MetaTrader 5. Ou seja, o terminal. Em breve irei mostrar como você poderá tornar as coisas bem mais interessantes. Mas para que este momento venha a acontecer, é preciso que primeiro, venhamos a construir um conhecimento sólido e consolidado a respeito de certas características se uma linguagem de programação.

Assim, este primeiro conteúdo, não é voltado única e exclusivamente ao MQL5. Ele pode ser aplicado em outras linguagens. Principalmente a parte referente a conceitos e regras de programação. Ok, como foi dito, no começo deste tópico, existem situações em que a biblioteca padrão do MQL5, não será capaz de nos atender. Mas utilizando o conhecimento mostrado nos outros artigos e com um pouco de raciocínio lógico. Você meu caro leitor, pode conseguir implementar muitas coisas interessantes. Mesmo que aparentemente tenhamos visto apenas coisas básicas e quase sem um proposito definido.

O fato de definirmos um propósito para um dado conhecimento. Não é de fato, a parte mais interessante de ser um programador. A parte interessante, é que conforme você vai compreendendo como certas coisas funcionam, e começa a pensar em maneiras de utilizar aquele conhecimento, para resolver um problema particular. É que de fato dá um propósito para aquilo que foi aprendido.

Agora quero que você pense no seguinte problema, meu caro leitor. Suponhamos que você queira visualizar, ou imprimir no terminal do MetaTrader 5, valores binários. O motivo não importa. Apenas o problema. Bem, você está com este desafio nas mãos. Então logo pensa: Bem, posso usar a formatação de string para apresentar valores binários no terminal. Perfeito. Este seria o primeiro pensamento, de um bom programador. Porém um programador com mais experiência já saberia a resposta. No entanto, um programador iniciante, iria buscar na documentação, uma forma de formatar a string, a ponto de mostrar a representação binária de algum valor numérico. Tendo suas tentativas frustradas. Já que tal coisa não existe. E é neste momento que a criatividade, aliada ao conhecimento começa a mostrar o caminho a ser seguido.

Muito bem, como a formatação para apresentar valores binários não existe, precisamos criar ela. Então você sendo um iniciante em programação, e tendo apenas o conhecimento mostrados nos artigos anteriores pode ficar achando que isto não seria possível de ser feito. Mas será mesmo? Bem, vamos ver se é ou não possível fazer isto. Tendo apenas visto o que foi mostrado nos demais artigos.

Primeiro sabemos que existe uma função na biblioteca padrão que nos permite formatar diversos modelos de dados. Assim, tudo que precisamos é criar o que seria o nosso padrão. Isto para que a formatação com valores binários pudesse ocorrer. Ok, esta é a parte fácil. Mas existe uma parte um pouco mais complicada de ser resolvida. Isto por que, diferente do C e C++, onde temos a possibilidade de adicionar um número ilimitado de dados, ou argumentos em uma função. Aqui no MQL5, não temos esta possibilidade. E até onde sei, C e C++, são as únicas linguagens que permitem este tipo de coisa. Tem o Assembly também, mas ninguém é maluco o suficiente a ponto de programar algo em Assembly. Para ser sincero isto sim seria um atestando de insanidade.

Certo. Este fato, de não podermos ter um número ilimitado de argumentos sendo passados para uma função, torna as coisas um tanto mais complicado. Isto à primeira vista. Pois podemos dividir o problema em pequenas etapas a serem resolvidas. Como queremos criar uma nova formatação, ao mesmo tempo utilizar uma já presente na biblioteca do MQL5. Podemos manipular os dados para conseguir isto. Como? Simples, meu caro leitor. Criamos uma função que retorne uma string com o valor já convertido em uma representação binária. Como a biblioteca padrão do MQL5, consegue lidar com uma string para formatar o texto. Fica fácil criar o que seria nossa formatação personalizada.

Talvez pensando desta maneira, isto pareça ser algo muito difícil de ser feito. Mas veja como é simples, olhando o código que é mostrado logo na sequência.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     uchar value = 138;
07. 
08.     PrintFormat("The value %d in binary is written as: %s", value, BinaryToString(value));
09. }
10. //+------------------------------------------------------------------+
11. string BinaryToString(const uchar arg)
12. {
13.     return "--BINARY--";
14. }
15. //+------------------------------------------------------------------+

Código 01

Quando executarmos este código 01, o resultado será o que podemos ver logo abaixo.

Imagem 01

Neste momento, você pode estar pensando: Cara, mas isto não é o que estávamos querendo fazer. De fato, meu caro leitor, isto não é o que desejamos. Mas serve para lhe mostrar que podemos usar o que já existe, para tentar criar algo novo. Bem, observe que a string colocada na linha 13 é a mesma que estamos visualizando na imagem 01. Ou seja, funciona.

Agora tudo que precisamos fazer é converter, ou traduzir o valor que a função está recebendo em uma representação binária. E colocar está representação dentro de uma string e retornar a mesma. Da mesma maneira que estamos fazendo na linha 13.

E como poderemos transformar o valor recebido em uma string que irá conter apenas zeros e uns? É bem simples fazer isto, meu caro leitor. E para tal coisa iremos usar um laço. Mas tem um pequeno detalhe aqui. Porém vou explicar isto, já dentro do código propriamente dito. Este pode ser visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     uchar value = 138;
07. 
08.     PrintFormat("The value %d in binary is written as: %s", value, BinaryToString(value));
09. }
10. //+------------------------------------------------------------------+
11. string BinaryToString(const uchar arg)
12. {
13.     string  sz0 = "";
14.     uchar   mask = 0x80;
15. 
16.     while (mask)
17.     {
18.         sz0 = sz0 + ((arg & mask) == mask ? "1" : "0");
19.         mask = mask >> 1;
20.     }
21. 
22.     return sz0;
23. }
24. //+------------------------------------------------------------------+

Código 02

Ao executar este código, você irá ver no terminal do MetaTrader 5. A imagem mostrada logo abaixo.

Imagem 02

Definitivamente, perfeito. Ou seja, com um conhecimento mínimo e bem básico, conseguirmos cumprir o desafio. Porém existe um pequeno detalhe neste código. Como o atual conhecimento, demonstrado até este ponto. NÃO PODEMOS usar qualquer tipo de dado para converte em sua representação binária. Não sem entrar em questões mais avançadas de programação. Porém para questões simples, onde usaremos apenas um único tipo de dado. No caso uchar. Já temos uma função que de fato funciona. E veja que ela é bem simples. E como tudo que está sendo feito aqui, foi explicado nos artigos anteriores. Não existe necessidade de que eu explique como esta função está conseguindo fazer sua tarefa. Porém, como o operador shift ainda não foi explicado. E ele está sendo utilizado nesta função. Acho prudente explicar como o mesmo trabalha. Mas isto será visto no próximo tópico. No entanto, antes de partirmos para o próximo tópico, quero chamar a sua atenção para um fato aqui, meu caro leitor. A variável mask deve ter a mesma largura de bits que a variável arg. Isto para que tenhamos uma perfeita conversão e tradução dos valores. Mas conforme novos artigos forem sendo postados e com material mais avançado. Iremos ver como fazer o compilador resolver este problema para nós. Isto a fim de que possamos usar qualquer tipo de dados. Desde tipos complexos até tipos mais simples. Sem mudar quase nada nesta função mostrada no código 02. Mas enfim, isto será visto no futuro. Neste momento vamos aprender como o operador shift funciona. Então vamos a um novo tópico.

Operador Shift, ou de deslocamento

Normalmente operadores são autoexplicativos. Mas este operador de deslocamento, pode ser um tanto confuso para algumas pessoas. Já que ele é um operador voltado exclusivamente para trabalhos com informações computacionais. Pelo menos desconheço a existência dele, fora da área de computação ou eletrônica digital. Mas este operador que você pode observar na linha 19 do código 02. É muito prático e até mesmo bem interessante em diversos casos. Porém ele NÃO é um operador especial. Ele apenas substitui outros dois operadores, que são mais prováveis de aparecerem em alguns códigos. Digo dois, pois existem dois operadores de deslocamento. Um para fazer deslocamento para direita e outro para fazer deslocamento para a esquerda. Algumas pessoas, quando estão começando a estudar programação, confundem estes operadores de deslocamento, com os operadores de relação. Onde procuramos saber se um valor é maior ou menor, em relação a outro valor. Porém, esta confusão de deve justamente a falta de atenção da pessoa. Já que o operador de deslocamento é composto de duas setas, seja para a direita, seja para a esquerda. Diferente dos operadores de relação, onde neste caso teríamos apenas uma única seta.

Bem, mas o que este operador de deslocamento está nos dizendo? Quando usado, este operador serve para nos dizer, quantos BITS iremos empurrar para a direita ou para a esquerda um dado valor. Este tipo de coisa parece um tanto quanto complicada à primeira vista. Porém, toda via e, entretanto, é MUITO mais simples do que utilizar os operadores que eles substituem. 

Mas como assim? Não estou entendendo. Se existe outra maneira de dizer a mesma coisa, por que não a usamos? Pelo menos você pode nós mostrar que maneira seria está? Mas é claro que posso mostrar, meu caro leitor. Na verdade, é justamente por conta disto que estou escrevendo este tópico. Quero que você entenda por que nem sempre uma mesma resposta, estará usando a mesma implementação. Dizer que dois programadores tiveram a mesma ideia para resolver o mesmo problema. É algo muito pouco provável. Porém, não estou dizendo que não pode ocorrer. Apenas que é muito pouco provável. Isto por que, a forma de resolver um problema, depende do nível de conhecimento e prática que cada um tem.

Mas vamos voltar a nossa  questão. E para explicar de maneira bem simples, clara e didática, o que os operadores de deslocamento fazem. Vamos brincar um pouco com o código visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const uchar shift = 1;
07.     uchar   i0 = 153,
08.             i1,
09.             i2,
10.             i3,
11.             i4;
12. 
13.     i1 = i0 << shift;
14.     i2 = i0 * (uchar)MathPow(2, shift);
15.     i3 = i0 >> shift;
16.     i4 = i0 / (uchar)MathPow(2, shift);
17. 
18.     PrintFormat("Shift value          : %d\n" + 
19.                 "Original             : %s\t%d\n" +
20.                 "Shifted to the left  : %s\t%d\n" +
21.                 "Multiplication result: %s\t%d\n" +
22.                 "Shifted to the right : %s\t%d\n" +
23.                 "Division result      : %s\t%d"
24.                 , shift, BinaryToString(i0), i0, 
25.                          BinaryToString(i1), i1, 
26.                          BinaryToString(i2), i2, 
27.                          BinaryToString(i3), i3, 
28.                          BinaryToString(i4), i4
29.                 );
30. }
31. //+------------------------------------------------------------------+
32. string BinaryToString(const uchar arg)
33. {
34.     string  sz0 = "";
35.     uchar   mask = 0x80;
36. 
37.     while (mask)
38.     {
39.         sz0 = sz0 + ((arg & mask) == mask ? "1" : "0");
40.         mask = mask >> 1;
41.     }
42. 
43.     return sz0;
44. }
45. //+------------------------------------------------------------------+

Código 03

Quando você executar este código irá visualizar a imagem mostrada logo abaixo.

Imagem 03

Agora preste atenção para entender o que estamos fazendo aqui, meu caro leitor. Este código 03, que a princípio parece muito confuso. É bem claro no seu objetivo e cumpre muito bem seu objetivo. Mas para entender ele você precisará ver o que significa a função MathPow. Como esta faz parte da biblioteca do MQL5. Olhe a documentação para mais detalhes. Porém de qualquer forma, ela simplesmente efetua o cálculo de potenciação. Mas nos retornar um valor do tipo double. Como nossos dados são do tipo uchar, fazemos uma conversão explicita de tipos. Assim o compilador não irá se queixar, nos informando que estamos trabalhando com tipos diferentes.

Agora, observe que na imagem 03 estamos mostrando, tanto o valor, quanto a representação binária do mesmo. Isto em cada uma das linhas. Esta representação binária aqui, é importante. Pois torna mais claro, o que ocorreu com o nosso valor original. Bem, você pode dizer que quando deslocamos um valor para a esquerda estamos multiplicando-o por dois. Já quando deslocamos para a direita estamos dividindo-o por dois. De certa maneira, você não está errado. Isto analisando a imagem 03. Porém se mudamos o valor de deslocamento, de um para três, por exemplo. O que acontecerá?

Imagem 04

A imagem 04 é o que irá ocorrer, quando usamos um deslocamento por três. Neste caso, você pode observar uma coisa bem estranha acontecendo quando deslocamos por três. Pois na verdade, não estamos multiplicando e dividindo por dois. Mas a conta está sendo feita por uma potência de dois. Ou seja, precisamos dividir por dois elevado a algum número, ou multiplicar por dois, elevado a este mesmo número. Para conseguir o resultado correto. Que seria feito justamente usando o operador de deslocamento. Como efetuar este tipo de operação, onde usamos uma potência e depois uma multiplicação ou divisão é mais oneroso. É preferível utilizar o operador de deslocamento.

Mas observando os valores na imagem 04. Você nota que parte da informação está desaparecendo. Isto não é um erro no programa, meu caro leitor. Isto é devido as questões de limite que cada tipo tem. Como o MQL5 é uma linguagem que faz uso de tipos, para definir suas variáveis. Quando saímos dos limites, parte da informação é perdida. Existem diversos meios de se evitar ou contornar isto. Mas neste momento, isto não vem ao caso. Podemos deixar a explicação de como fazer isto, para uma outra oportunidade. Que sempre irá surgir. Acredite, em programação, sempre existe oportunidade para novos aprendizados.

Acredito que tenha ficado claro, como este operador de deslocamento funciona. Desta forma, aquele código 02, fica totalmente esclarecido e perfeitamente compreendido. Podemos tratar de um outro assunto. Mas ainda ligado de alguma forma ao tema, string e arrays.

Pangrama e Anagrama

Existe uma aplicação muito curiosa e em alguns casos até mesmo divertida. Que podemos neste momento, mesmo com muito pouco conteúdo já tendo sido visto. Falarmos sobre ela. Trata-se de pangramas. Um pangrama seria uma frase, que usamos todas a letras e um alfabeto para fins de testes. Sendo algo relativamente antigo, pode nos fornece um tipo de atividade bem interessante e bastante didática. Talvez o pangrama mais famoso de todos, é:

A QUICK BROWN FOX JUMPS OVER THE LAZY DOG 0123456789

Este foi utilizado para efetuar testes em antigos telégrafos. Já que informava todos os caracteres que poderiam aparecer em uma frase. Mas o que pode ter deixado ele ainda mais famoso, foi quando a Microsoft o utilizou no Word, afim de demonstrar como o texto seria impresso. Isto na época foi inclusive usado por algumas pessoas para dizer que existiam coisas ocultas nas ferramentas da Microsoft. Algo que fazia muita gente ficar com medo de usar computadores.

Mas mesmo dentro do que estamos tratando e lidando, neste momento. Podemos brincar com este tipo de frase. Isto a fim de demonstrar e aprender certas coisas sobre strings e arrays. Como é algo bem simples e muito divertido. Acredito que você vai gostar de entender como funciona.

Não é raro, ouvirmos falar para utilizar senhas fortes e até mesmo frases com senha. Porém criar senhas fortes ou mesmo lembrar das mesmas é uma tarefa muito complicada. Por outro lado, muita gente diz, e você vai encontrar muito a este respeito. Informando que existem programas especializados em armazenar senhas. Mas se tais programas precisam de uma senha, para guardar outras de maneira segura. Ao meu ver isto não ajuda muito.

Porém, mesmo um programador iniciante, que já consegue entender como alguns comandos e funções básicas trabalham. Consegue criar uma aplicação para gerar uma senha relativamente forte. Claro, que a força da senha a ser criada, irá depender de algumas características do sistema que será programado. No entanto, mesmo seguindo esta lógica. Você, meu caro leitor, conseguirá criar algo bem interessante. Desde que tenha um pouco de criatividade para melhorar o que irei mostrar aqui. Já que o objetivo aqui é basicamente a didática.

Para começar, vamos pensar no seguinte: O que é uma senha? Bem, uma senha é basicamente um conjunto de caracteres imprimíveis, que estão em uma string. Então se pegarmos uma string e trabalharmos em cima dela, poderemos criar um programa que consegue embaralhar ou criptografar a string. Como o objetivo é criar uma senha forte, este embaralhamento, que pode ser uma criptografia, ou mesmo um anagrama, irá de fato conseguir ocultar, mesmo que parcialmente a senha original. Porém anagramas não são muito bons em esconder uma informação, cujo objetivo é ser usada em outro local. No caso uma senha. O melhor mesmo é utilizar em embaralhamento ou criptografia. Isto usando um anagrama ou um pangrama como frase de codificação. A chave em si será a frase que você consegue decorar. E o resultado final será o que usaremos, ou poderemos usar como senha.

Para que você meu caro leitor entenda o que estou tentando lhe descrever. Vamos ver um primeiro código bem básico e sem muita pretensão. Este pode ser visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const string sz_Secret_Phrase = "Um pequeno jabuti xereta viu dez cegonhas felizes";
07. 
08.     Print("Result:\n", PassWord(sz_Secret_Phrase));
09. }
10. //+------------------------------------------------------------------+
11. string PassWord(const string szArg)
12. {
13.     const string szCodePhrase = "The quick brown fox jumps over the lazy dog";
14. 
15.     string  szPsw = "";
16.     uchar   pos;
17. 
18.     for (int c = 0; c < StringLen(szArg); c++)
19.     {
20.         pos = (uchar)(StringGetCharacter(szArg, c) % StringLen(szCodePhrase));
21.         szPsw = StringFormat("%s%c", szPsw, StringGetCharacter(szCodePhrase, pos));
22.     }
23. 
24.     return szPsw;
25. }
26. //+------------------------------------------------------------------+

Código 04

Olhando este código, você deve estar pensando: Cara, que maluquice é estar que você está tentando fazer aqui? Calma meu caro leitor. Sei que isto que estamos fazendo aqui, parece um tanto quanto algo maluco e sem sentido. Mas logo você entenderá o que estou querendo mostrar. Observe o seguinte: Este código utiliza somente o que foi visto até este momento. Nada de novo está sendo adicionado aqui. Tudo que está sendo feito aqui, pode ser perfeitamente entendido, se você compreendeu os artigos anteriores e procurar estudar as funções de biblioteca usadas neste código. Já que aqui estamos utilizando coisas que podem ser facilmente encontradas na documentação do MQL5. Sendo assim não vou entrar em detalhes sobre as funções utilizadas aqui. Porém, ao executar este código, SEM NENHUMA MODIFICAÇÃO. Você irá ver a imagem mostrada logo abaixo.

Imagem 05

A região marcada na imagem 05, representa a senha que você deveria utilizar. Mas observe que ela é um tanto quanto furada, pelo símbolo de espaço. Normalmente senhas, não utilizam espaços em nenhum ponto das mesmas. Assim sendo precisamos corrigir isto. Uma forma muito simples de corrigir, isto é, removendo os espaços e colocando a primeira letra em maiúsculo. Veja que é algo muito simples de ser feito. Ao fazer esta mudança, que deverá ser feita na linha 13 do código 04. Teremos algo parecido com o que é visto no código abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const string sz_Secret_Phrase = "Um pequeno jabuti xereta viu dez cegonhas felizes";
07. 
08.     Print("Result:\n", PassWord(sz_Secret_Phrase));
09. }
10. //+------------------------------------------------------------------+
11. string PassWord(const string szArg)
12. {
13.     const string szCodePhrase = "TheQuickBrownFoxJumpsOverTheLazyDog";
14. 
15.     string  szPsw = "";
16.     uchar   pos;
17. 
18.     for (int c = 0; c < StringLen(szArg); c++)
19.     {
20.         pos = (uchar)(StringGetCharacter(szArg, c) % StringLen(szCodePhrase));
21.         szPsw = StringFormat("%s%c", szPsw, StringGetCharacter(szCodePhrase, pos));
22.     }
23. 
24.     return szPsw;
25. }
26. //+------------------------------------------------------------------+

Código 05

Nesta hora, olhando e comparando o código 05 com o código 04, você pode dizer: Mas não mudou nada. Isto não vai funcionar. O resultado será muito parecido com o resultado anterior. Mas será mesmo que é isto que ocorrerá, meu caro leitor? Bem, vejamos então. Assim que este código 05 for executado, o resultado será o que é visto na imagem abaixo.

Imagem 06

Caramba. Mudou e mudou muito. É totalmente diferente. Não tem nada a ver com o que foi visto na imagem 05. Observe que muitos pensam ou imaginam que para programar algo assim, é preciso ser um gênio da matemática ou alguém muito experiente e com vários anos de programação. No entanto, aqui estou mostrando, que você, tendo um mínimo de conhecimento sobre programação, aliado com uma boa dose de criatividade. Consegue resultados muito bons e até mesmo surpreendentes. Mas se você achou que esta senha está muito simples, porém apenas bastante longa. Podemos resolver isto muito facilmente. Note que a única diferença entre o código 04 e o código 05 é exatamente a linha 13. Nenhuma outra linha foi modificada. Então neste momento é natural pensar o seguinte: E se fosse adicionado alguns símbolos extras nesta linha 13. Será que a senha iria ficar melhor? Bem, podemos tentar isto também, meu caro leitor. Assim vamos mudar a linha 13, para esta linha vista logo na sequência.

    const string szCodePhrase = ")0The!1quick@2brown#3fox$4jumps%5over^6the&7lazy*8dog(9";

E o resultado será este mostrado logo abaixo.

Imagem 07

E então meu caro leitor, é ou não é algo divertido isto que estamos fazendo? E olha que estou usando uma programação simples e muito básica. Mas podemos deixar as coisas um pouco melhores. Porém isto irá exigir um código um pouco diferente.

No entanto, vou fazer algo um pouco diferente. Isto para que você possa compreender um outro detalhe que foi dito no artigo anterior. Lá falei que o tipo string NÃO existe em C e C++. Porém no MQL5, este tipo existe, justamente para evitar que venhamos a precisar usar um modo de programação que existe no C e C++. Isto por que no C e C++, uma string é na verdade um array que contém um valor especial, que indica onde a string finaliza. Como o MQL5, utiliza o mesmo valor para indicar a mesma coisa, podemos modificar este código que cria uma senha, para não utilizar as chamadas da biblioteca padrão do MQL5.

Mas, e agora quero que você preste atenção, vamos usar algo no MQL5, que é utilizado no C e C++. Por isto o MQL5, fica em um meio termo, como falei no artigo anterior. No entanto, aqui vou apenas dar uma breve introdução no tema que será melhor explicado no próximo artigo.

Strings são arrays

O título deste tópico indica exatamente o que ocorre bem lá no íntimo da programação. Sei que para muitos isto que está sendo dito no título deste tópico parece confuso. Mas no próximo artigo iremos tratar isto de maneira um pouco mais profunda. Porém, quero deixar aqui, um fato para que você comece a estudar as coisas o quanto antes. Pois as coisas irão ficar bem complexas e de forma muito rápida no momento em que começarmos a falar sobre este assunto no próximo artigo.

Mas aproveitando este momento, podemos mudar o código visto no tópico anterior, para que ele comece a usar a string, como sendo um array. Parece bem maluco fazer isto. Mas existem algumas vantagens em termos de programação quando começamos a fazer isto.

Desta maneira, o código 04, visto antes, fica como mostrado logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     const string sz_Secret_Phrase = "Um pequeno jabuti xereta viu dez cegonhas felizes";
07. 
08.     Print("Result:\n", PassWord(sz_Secret_Phrase));
09. }
10. //+------------------------------------------------------------------+
11. string PassWord(const string szArg)
12. {
13.     const string szCodePhrase = "The quick brown fox jumps over the lazy dog";
14. 
15.     uchar   psw[],
16.             pos;
17. 
18.     ArrayResize(psw, StringLen(szArg));
19.     for (int c = 0; szArg[c]; c++)
20.     {
21.         pos = (uchar)(szArg[c] % StringLen(szCodePhrase));
22.         psw[c] = (uchar)szCodePhrase[pos];
23.     }
24.     return CharArrayToString(psw);
25. }
26. //+------------------------------------------------------------------+

Código 06

Quando este código 06 for executado, o resultado será idêntico ao mostrado na imagem 05. Mas se você modificar a linha 13, como foi explicado no tópico anterior. Irá notar que os resultados serão os mesmos mostrados anteriormente. Porém, este código 06, tem algumas vantagens. Já que aqui, estamos fazendo uso de um sistema de array, e não utilizando uma string diretamente. O tipo de vantagem que isto nos traz será melhor explicado no próximo artigo. Onde darei maiores explicações de como tirar proveito deste tipo de modelagem. E por incrível que pareça, meu caro leitor. Este código ainda é ao meu ver, um código que qualquer iniciante bem instruído e que tenha sido dedicado aos estudos, consegue perfeitamente compreender. Isto sem que eu venha a dar nenhuma explicação de como ele funciona.

De qualquer forma, no próximo artigo, irei explicar este código com a calma que ele merece. Só estou mostrando-o agora e aqui, para que você não deixe o material se acumular. Imaginando que pôr está simples e fácil, pode ir deixando para começar a estudar em outro momento.

Considerações finais

Neste artigo, que ao meu ver foi bem divertido. Criamos algo prático e que tem algum tipo de proposito, que não seja somente aplicação de partes teóricas. Sei que alguns pontos visto aqui, podem assustar no primeiro momento. Porém isto não deve de forma alguma ser motivo para que você desista. Pelo contrário. Quero mostrar com este artigo. Que mesmo um programador iniciante, mas com uma boa dose de criatividade e alguma malandragem. Consegue criar, e manipular dados de texto. Isto a fim de criar algo que muitos consideram ser necessário anos de prática em programação.

Acredito, que o fato de ter visto estas coisas sendo feitas, com um mínimo conhecimento. Já que tudo que foi feito aqui, pode ser compreendido com base no que foi visto nos artigos anteriores. Tornará você mais ativo. E menos relaxado achando que tudo que havia sido mostrado não serviria para nada. E aí está. Então divirta-se com os arquivos presentes no anexo. E já fica marcado. Temos um encontro no próximo artigo. Onde o assunto será ARRAYS.