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

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: Precedência de operadores, falamos um pouco sobre os cuidados que precisamos tomar quando formos utilizar fatorações em nossos códigos. Não é raro, ver códigos onde aparentemente está tudo correto, mas que acabam gerando resultados completamente estranhos em determinados momentos. Normalmente este tipo de coisa está diretamente relacionada com a forma como as fatorações estão sendo feitas. Fazer com que um código de fato produza resultados coerentes, parece ser uma tarefa trivial. Porém, sem o devido conhecimento, demonstrando naquele artigo. As chances de uma falha catastrófica em um código, cresce à medida em que mais e mais fatorações implementadas de qualquer maneira surgem no código.

Como a parte teórica sobre como criar adequadamente fatorações é bastante chata e tediosa. Não vamos ficar atados a ela. Vamos fazer as coisas na prática. Porém, aconselho a você meu caro leitor, sempre que possível, procure experimentar modificar um pouco os códigos que estou disponibilizando. Tentando criar fatorações diferentes, ou mesmo um controle de fluxo de execução um pouco diferente do que estará nos arquivos presentes no anexo.

Fazer isto é muito importante, para que você comece a praticar maneiras de gerar um mesmo resultado. Porém seguindo um caminho diferente, do qual você mesmo terá construído. Ao fazer este tipo de coisa, que muitos consideram perda de tempo, você estará praticando da melhor forma que existe. Isto por que, no anexo, você terá um código que de fato funciona. E que irá gerar um tipo de resultado. O desafio aqui, é criar um código diferente, mas que gere o mesmo tipo de resultado. Depois de um tempo fazendo este tipo de coisa, você irá de fato se tornar apto a criar suas próprias soluções. Mesmo que inicialmente elas não lhe pareçam assim tão profissionais.

Muito bem, dada esta pequena palestra, de como você pode estudar na prática, como trabalhar com os operadores. Vamos ao assunto que será visto neste artigo. Existe um pré-requisito para este artigo. E para atender o mesmo, você precisa já estar dominando o assunto referente a declaração e uso de variáveis e constantes. Apesar do assunto que será visto aqui, ter muito mais a ver com operadores do que com qualquer outra coisa. O conhecimento e domínio de como declarar, inicializar e utilizar variáveis e constantes, se tornar primordial para entender o que será explicado. Aqui vamos começar a falar sobre alguns tipos de dados especiais. Esta parte, onde irei tentar ao máximo não ficar somente na parte teórica. É talvez, junto com as regras de precedência, vistas no artigo anterior, um dos assuntos mais complicados que existe. Isto conforme formos avançando no assunto. Porém, neste primeiro momento iremos tratar das coisas em seu âmbito mais simples que seja possível apresentar o assunto. No entanto, é algo realmente necessário antes de falarmos de um outro tema ainda mais espinhento. Então como de praxe vamos ao tópico inicial.

Arrays e Strings

Sem nenhuma sobra de dúvida. Este assunto é uns dos que causa mais confusão, e desistência de novos programadores para utilizar linguagens tipadas. Isto por que, linguagens não tipadas, como Python e JavaScript, lidam com este tipo de tema de uma maneira quase transparente. Onde de fato, o programador, não precisa se preocupar em definir as coisas. Ele simplesmente as utiliza.

Por outro lado, linguagens como C e C++, torna este tipo de tema, algo extremamente complicado. Devido justamente a maneira como estas duas entidades são tratadas dentro do C e C++. Neste caso, elas não são duas entidades, mas apenas uma, e dependendo da forma como você trabalha com elas, pode surgir uma terceira ou quarta entidade dentro deste mesmo tema. Ou seja, uma complicação para novos programadores poderem lidar.

Porém, aqui no MQL5, ficamos em um meio termo, entre o que seria uma linguagem tipada como C e C++ e uma não tipada como Python ou JavaScript. E por que estou dizendo isto? O motivo é que diferente de C e C++, onde podemos ignorar o tipo de dado presente em um Array. E em alguns casos em strings também. Aqui no MQL5, não existe esta possibilidade. Pelo menos não sem que venhamos a fazer certos tipos de manipulação. O que de fato torna o aprendizado um pouco mais simples. No entanto, sem uma base sólida e bem consolidada, fica praticamente impossível criar certos tipos de manipulação de dados aqui no MQL5, da mesma forma que faríamos de maneira muito simples no C e C++. Entretanto, apesar disto, é muito mais difícil que você como programador iniciante, crie algo em MQL5, que venha a fugir do seu controle. Diferente do que acontece em C e C++, onde qualquer mínimo deslise e pronto. Você tem uma bomba relógio em suas mãos, pronta para detonar ao primeiro vacilo que você vier a cometer.

Mas aqui entre nós. Aprender MQL5 é consideravelmente mais fácil do que aprender, a fazer as mesmas coisas em C ou C++. Então fico bastante feliz de compartilhar e traduzir meu conhecimento em C e C++, para que seja utilizado aqui no MQL5. E de quebra, quem sabe ensinar um de vocês a alcançar um bom nível de conhecimento em programação.

Mas chega de conversa, vamos iniciar, o nosso assunto principal aqui. Para começar, vamos deixar claro uma coisa aqui. Arrays e Strings, são de certa maneira a mesma coisa. Isto olhando pelo ponto de vista dos dados presentes na memória. Para ser exato, uma string nada mais é do que um array. Só que um array especial. Digo especial, por conta de um detalhe que existe na string, mas não existe em um array qualquer. Este detalhe é um marcador que nos diz, ou melhor nos permite saber onde a string termina.

Aqui vou fazer um pequeno paralelo entre outras linguagens. Coisa simples, só para deixar claro do que estamos falando. Algumas linguagens de programação, como por exemplo, linguagens baseadas no BASIC. Sim o velho e antigo BASIC que surgiu lá nos tempos do MS-DOS. Tem como seu primeiro caractere, um dado que nos diz quantos caracteres, ou quantos valores estão presentes em uma string. Este tipo de coisa, permite que usemos qualquer caractere dentro da string. Já que o tamanho da string está sempre sendo informado no primeiro caractere da mesma. Mas este primeiro caractere, que pode conter mais de um byte, não será impresso hora nenhuma. Ele é invisível para o usuário. Sendo visto apenas por meio do código. Ok, isto nos dá a liberdade de usar qualquer caractere, ou valor numérico dentro da string. Porém isto limita as coisas a largura em termos de bits do primeiro caractere. Onde teremos o comprimento da string.

Linguagens baseadas em C e C++, utilizam um outro método. Neste caso temos um caractere, ou valor especial que nos dirá onde a string termina. O tipo string de fato não existe em C e C++. Normalmente o caractere ou valor utilizado é um NULL ou zero. Quando este valor surge na string, teremos ali a marcação de fim da string. Por um lado, isto nos permite criar uma string que possa ocupar, literalmente toda a memória disponível no equipamento. Por outro lado, isto nos limita a não poder usar um dado valor dentro de uma string.

O MQL5, por ser baseado em C e C++, utiliza esta mesma abordagem. Porém diferente do C e C++, no caso do MQL5, existe um tipo chamado string. Por isto, não podemos fazer certas coisas usando diretamente e exclusivamente o tipo string em todo e qualquer código. O ideal seria utilizar um array. Mas ao fazermos isto, temos outros inconvenientes que nos são apresentados. Porém e felizmente, a biblioteca do MQL5, é suficientemente vasta para que tais inconvenientes possam ser de alguma forma contornados. Em alguns casos de maneira mais simples, em outros de maneira um pouco mais complicada.

Bem, mas por que estou falando este tipo de coisa? O motivo é simples: Sem que você compreenda adequadamente este tipo de modelagem. Você ficará amarrado e aprisionado a um número finito de opções. Não conseguindo de fato efetuar certos tipos de tarefas. Ainda mais tarefas que exigem um nível mais avançado em termos de programação. Não é raro, ver pessoas se queixando de que não dá para fazer isto ou aquilo utilizando o MQL5. Mas quando você analisa o nível de conhecimento de tais programadores, nota que eles estão completamente presos a certos conceitos e ideias, das quais não lhes permite ir um pouco além do que está sendo oferecido na biblioteca padrão.

Não que utilizar a biblioteca padrão, seja uma falta de conhecimento. Pelo contrário. Mas se você não compreende como as coisas realmente estão correlacionadas, irá ficar sempre se queixando que não é possível fazer as coisas que você gostaria de fazer.

Então meu caro leitor, entenda o seguinte: Arrays são o que poderíamos dizer como sendo uma string genérica. Onde podemos colocar qualquer coisa ali dentro. Uma string é um tipo de construção, onde existem limitações e muitas vezes proibições. Se você quer realmente fazer algo, e não sabe, quais limitações ou restrições um array ou uma string contém. Você não conseguirá de fato fazer tal coisa. Talvez o que torne o uso de arrays um tanto quanto complicado, é o fato de que uma string é um array do tipo uchar, ou ushort. Dependendo do código de caracteres que estaremos utilizando. Mas um array puro, pode ser de qualquer tipo. Podendo ser desde uma classe até um do tipo booleano. Isto de fato complica muito as coisas para quem está começando a aprender programação. Mas como quero lhe mostrar um caminho que pode ser seguido. Vamos começar com o tipo mais básico. Ou seja, vamos começar com as strings.

Dados do tipo Strings

Quando criamos, ou declaramos algo como sendo uma string, estamos dizendo ao compilador, que queremos criar um array. Mas um array especial, onde termos um caractere ou valor que irá indicar onde a string termina. Em um nível bem mais profundo, ao utilizarmos uma variável string, não precisamos fazer a alocação da memória. Este trabalho será feito pelo nosso código, à medida que se torna necessário, mais ou menos memória sendo utilizada.

Isto nos permite fazer uma serie enorme de coisas, sem muita preocupação. Por outro lado, temos algumas limitações. Mas não vamos nos preocupar com estas limitações. Vamos nos ater ao que podemos fazer. Lembrando que você somente conseguirá dominar tais coisas, praticando bastante. Aqui iremos apenas arranhar a superfície. Então vamos começar com o nosso primeiro código. Este é mostrado logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     string  sz0 = "Hello world !!!",
07.             sz1 = "My first operation with strings...",
08.             sz2;
09. 
10.     sz2 = sz0 + sz1;
11. 
12.     Print(sz2);
13. }
14. //+------------------------------------------------------------------+

Código 01

Agora preste atenção meu caro leitor. Aqui temos três variáreis do tipo string sendo criadas. Duas delas estão sendo declaradas no momento de sua criação. Já a terceira, recebe o que seria uma união das duas outras. Criando assim uma nova string. A linha 12 simplesmente imprime o resultado no terminal. Como você pode ver logo abaixo.

Imagem 01

O grande detalhe aqui é o seguinte: Note que na linha 10 estamos utilizando um operador de soma. Este é um dos, se não o único operador, que por padrão irá fazer algo em um tipo string. E no caso, irá unir uma string a outra. Porém tome muito cuidado com este tipo de conceito. Isto por que operadores nem sempre fazem o que esperamos que eles façam. Mas isto será visto e melhor compreendido em outro momento. Por hora, apenas tome cuidado, quando estiver mexendo com um código que você não conheça.

Ok, temos uma frase sendo mostrada no terminal. Mas e se desejarmos separar as coisas em linhas. Como faríamos isto? Bem meu caro leitor. Uma forma seria colocar duas chamadas o procedimento Print. Mas se você desejar colocar uma quebra de linha na própria string, pode fazer isto utilizando alguns dos marcadores especiais.

Existem diversos marcadores especiais que podem aparecer em uma string. E todos eles, pelo menos aos que podem ser utilizados aqui no MQL5, derivam do C/C++. Assim caso você queira adicionar uma quebra de linha em algum ponto, bastará adicionar algo como mostrado abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     string  sz0 = "Hello world !!!",
07.             sz1 = "My first operation with strings...",
08.             sz2;
09. 
10.     sz2 = sz0 + "\n" + sz1;
11. 
12.     Print(sz2);
13. }
14. //+------------------------------------------------------------------+

Código 02

Aqui temos um destes marcadores sendo utilizados. Estes marcadores como este "\n", são mais conhecidos como sequência de escape. Se você procurar, irá ver um monte destes pequenos códigos. Mas ao colocar este tipo de marcador na string. O código mudará e termos agora a possibilidade de ter o resultado mostrado abaixo.

Imagem 02

Porém este tipo de marcador não faz somente isto. Por exemplo, podemos eliminar parte de um texto, se usarmos um marcado NULL, como você pode observar logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     string  sz0 = "Hello world !!!",
07.             sz1 = "My first operation \0with strings...",
08.             sz2;
09. 
10.     sz2 = sz0 + "\n" + sz1;
11. 
12.     Print(sz2);
13. }
14. //+------------------------------------------------------------------+

Código 03

Ao executar este código 03, teremos no terminal do MetaTrader 5, a imagem mostrada na sequência.

Imagem 03

Observem como tudo é muito fácil e simples de entender. Mas além disto, também podemos criar strings com valores numéricos. Mas neste caso, precisamos recorrer a funções da biblioteca padrão do MQL5. Isto para que a conversão seja mais fácil e simples. Talvez futuramente eu venha a mostrar como você pode criar sua própria versão para um proposito parecido. Mas isto fica para outro momento. Então usando as funções de conversão presentes no MQL5, podemos converter números em string e string em números.

Este tipo de coisa é extremamente útil e necessário em diversos momentos. Principalmente na criação de sistemas de análise de dados. Um exemplo simples disto é mostrado logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     int     i_value = 65538;
07.     double  d_value = 0.25;
08.     color   cor = clrRed;
09.     string  sz0;
10. 
11.     sz0 = "Color: " + ColorToString(cor) + "\nInteger: " + IntegerToString(i_value) + "\nDouble: " + DoubleToString(d_value);
12. 
13.     Print(sz0);
14. }
15. //+------------------------------------------------------------------+

Código 04

Ao executar este código 04, você verá algo parecido com a imagem abaixo.

Imagem 04

Note que conseguimos criar uma string, com diversas informações. Porém em alguns casos precisamos que a string que estaremos criando, tenha um formato muito específico. Seja devido ao tipo de informação que queremos seja por conta de formatação dos próprios dados a serem utilizados. Neste caso, precisamos fazer as coisas de uma maneira um tanto quanto diferente, do que foi mostrado até aqui. Mas devido a natureza do que será visto. Acredito que seja bom separar as coisas em um novo tópico. Assim será mais fácil de você estudar e praticar o conhecimento que está sendo mostrado aqui.

Formatando strings

Quando se fala em formatação de texto, muita gente pensa em editores de texto. Porém quando falamos este tipo de coisa, e estamos mencionando algo relacionado a programação. Estamos na verdade nos referindo ao fato de que algumas informações precisam cumprir certos critérios, antes mesmo de serem utilizadas, ou mesmo impressas.

Tais critérios é o que constitui a formatação de uma string. A princípio este tipo de coisa é relativamente simples e fácil de ser utilizada. Nos permitindo criar strings com informações muito específicas e de maneira bastante fácil. Porém existem alguns cuidados, ou melhor dizendo, detalhes dos quais você, como programador deverá observar. Entre estes detalhes está o uso e construção dos parâmetros de saída. Se bem configurados, estes parâmetros tornam a vida de um programador, mesmo um iniciante, bastante simples e direta. Já que eles substituem em grande parte o tipo de montagem que foi vista no tópico anterior. Ao mesmo tempo de nos permite ajustar e nos dar uma boa liberdade de construção. Isto para que venhamos a conseguir criar uma string bem específica.

Ok, você já deve ter visto, em algum código a utilização do procedimento de biblioteca PrintFormat. Este procedimento, de certa maneira é nos permite colocar no terminal do MetaTrader 5, algum tipo de informação formatada. No caso uma string. Porém nem sempre queremos, ou é desejável jogar a informação, ou string para o terminal. Muitas vezes queremos ou desejamos utilizar a informação para um outro objeto. Seja armazenar as coisas em arquivo. Seja lança-las ou utiliza-las em um objeto qualquer presente no gráfico. Bem isto não importa. De qualquer forma, o procedimento PrintFormat, não nos serve em todas a ocasiões. Porém existe uma função que nos atende de maneira sublime. Que é a StringFormat.

Esta função StringFormat, utiliza o mesmo tipo de parametrização da PrintFormat. Porém a saída dela, diferente da PrintFormat, pode ser direcionada para uma string. O que realmente torna bastante interessante o seu uso, em diversas ocasiões.

Assim sendo, podemos criar uma saída para o que foi visto no código 04, em um estado já formatado. Sei que neste momento, você pode ficar meio que sem entender alguns dos parâmetros envolvidos. Mas deixo aqui a dica, isto para que você procure estudar cada um dos parâmetros com calma. Leia a documentação, na parte referente ao procedimento PrintFormat. Ali você irá ver uma série de informações. Cada uma delas mostra como podemos criar a formatação da string que desejamos ter na saída. Para exemplificar isto, vamos modificar o código 04, para que ele seja formatado. Com isto teremos o código visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     int     i_value = 65538;
07.     double  d_value = 0.25;
08.     color   cor = clrRed;
09.     string  sz0;
10. 
11.     sz0 = StringFormat("Color: %s\nInteger: %d\nDouble : %.2f", ColorToString(cor), i_value, d_value);
12. 
13.     Print(sz0);
14. }
15. //+------------------------------------------------------------------+

Código 05

Quando você executar este código 05, irá observar no terminal do MetaTrader 5, algo parecido com a imagem que é vista na sequência logo abaixo.

Imagem 05

Note as diferenças que existem aqui entre a imagem 04 e esta imagem 05. Apesar de estamos utilizando algo muito parecido em ambos os casos. A informação presente na imagem 05, está em um formato que foi especificado no nosso código. Isto durante a implementação da linha 11. Bem, você até poderia questionar que este tipo de coisa, não se faz necessário aqui. Mas vamos considerar que em algum momento, você esteja lidando com valores hexadecimais. Muitos programas, costumam fazer uso deste tipo de valor, em algum ponto, onde estamos trabalhando com bits. Assim, se você por um acaso desejasse visualizar este tipo de valor, a fim de checar se tudo está ocorrendo como o esperado. Como você faria isto?

A forma de fazer isto depende muito. Mas no geral você poderia utilizar a esta formatação, vista no código 05, para poder visualizar valores hexadecimais. Outro poderiam até mesmo dizer que faria sentido criar um código apenas para isto. Porém, ao meu ver isto é mais uma perda de tempo, e algo voltado a satisfação pessoal do que necessariamente algo que precisa ser feito. De qualquer maneira, todo programador é livre para fazer suas próprias escolhas. No entanto, como você, meu caro leitor, está começando na programação. O ideal é utilizar funções e procedimentos fornecidos pela biblioteca padrão. No caso usar a função StringFormat. Isto a fim de criar a representação dos valores hexadecimais que serão mostrados depois. Para tal, vamos ainda utilizar o mesmo código 05. Porém modificando a formatação da string que será criada. Isto é muito fácil e bastante direto de ser feito. Basta substituir a linha 11 por esta linha mostrada abaixo.

    sz0 = StringFormat("Color: 0x%X\nInteger: 0x%X\nDouble : %.2f", cor, i_value, d_value);

Ao executar novamente o código, depois de ter feito esta mudança. O resultado será o que é visto logo abaixo.

Imagem 06

Legal, não é mesmo? Porém temos um pequeno problema aqui. E é por isto que eu falei que você precisa ficar atendo aos detalhes envolvidos na formatação da string. O problema no caso é o valor da cor. Note que ela está no formato hexadecimal. Porém este valor mostrado na imagem 06, não necessariamente significa que a cor é vermelha. Este valor pode muito bem representa uma outra cor. Lembre-se que o formato da cor é RGB. E em alguns casos ARGB. Assim, apenas olhando este valor fica difícil saber exatamente do que se trata. Porém com um pequeno ajuste podemos mudar o valor para que ele seja de fato representativo para nós. Para isto bastará mudar o código para algo como o mostrado logo abaixo.

    sz0 = StringFormat("Color: 0x%06X\nInteger: 0x%X\nDouble : %.2f", cor, i_value, d_value);

Ao executar o código com esta modificação, você verá algo como o mostrado logo abaixo.

Imagem 07

Epá, espere um pouco aí. Está definitivamente não é a cor vermelha. Isto daí é a cor azul. O que houve aqui? Será que o problema foi o fato de estamos dizendo para adicionar alguns valores iguais a zero, antes do valor que será mostrando? Criando assim a formatação desejada? É mais ou menos isto. Porém não é bem assim, como você possa estar imaginando inicialmente. O que aconteceu aqui, na verdade é algo um pouco mais complicado de se explicar sem mostrar outro exemplo, onde utilizaremos o mesmo conceito aplicado a formatação do valor da cor. Isto para que ele venha a ser apresentado no formato hexadecimal.

Para exemplificar o que aconteceu aqui. Vamos mudar o valor da variável i_value e pedir para que ela seja formatada da mesma maneira que formatamos o valor da cor. Ou seja, poderá haver alguns zeros antes. Isto dependendo do valor que deverá ser apresentado. Para ficar mais claro, veja o código que é mostrado na sequência.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     int     i_value = 0xF;
07.     double  d_value = 0.25;
08.     color   cor = clrRed;
09.     string  sz0;
10. 
11.     sz0 = StringFormat("Color  :\t0x%06X\t=>\t%s\n" + 
12.                        "Integer:\t0x%06X\t=>\t%d\n" +
13.                        "Double :\t%.2f", cor, ColorToString(cor), i_value, i_value, d_value);
14. 
15.     Print(sz0);
16. }
17. //+------------------------------------------------------------------+

Código 06

Quando você executar este código 06, irá ver algo parecido com a imagem abaixo.

Imagem 08

Aqui dividi as coisas de modo que você, meu caro leitor, consiga compreender o que quero mostrar. Observe que na linha 11 do código iremos imprimir dois valores. Assim como na linha 12. Isto está sendo feito para que você possa entender, por que o valor em hexadecimal para cor é mostrado desta maneira. Observe que o valor para i_value, de fato parece adequado. Então vamos substituir o valor de i_value, para um valor maior. Ao fazemos a modificação, que é mostrada na linha abaixo, o resultado continua sendo bastante consistente, como você verá na imagem mostrada na sequência.

    int     i_value = 0xDA09F;

Imagem 09

Ou seja, a formatação funciona perfeitamente. Mas por que ela não está colocando o valor da cor em hexadecimal de forma correta? O motivo para isto é que apesar da formatação esperada por nós, ser RGB, ela internamente é feita usando BGR. Ou seja, ela é o contrário do que se imagina. Por isto o valor que está sendo mostrado no campo hexadecimal parece estar errado. Quando na verdade ele está de fato correto. Mas será que podemos mudar isto? Deixando as coisas de uma maneira que seria esperado por nós? Sim, meu caro leitor, podemos mudar isto sim. E com o conhecimento já mostrado nos demais artigos, fazer isto é, até bastante simples. Assim um provável código que conseguiria cumprir este objetivo é visto logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. void OnStart(void)
05. {
06.     int     i_value = 0xDA09F;
07.     double  d_value = 0.25;
08.     color   cor = clrRoyalBlue;
09.     string  sz0;
10. 
11.     sz0 = StringFormat("Color  :\t0x%06X\t=>\t%s\n" + 
12.                        "Integer:\t0x%06X\t=>\t%d\n" +
13.                        "Double :\t%.2f", cor, ColorToString(cor), i_value, i_value, d_value);
14. 
15.     Print(sz0);
16.     PrintFormat("Color value in hexadecimal (RGB format): %s", ColorToStrHex(cor));
17. }
18. //+------------------------------------------------------------------+
19. string ColorToStrHex(const color arg)
20. {
21.     return StringFormat("0x%02X%02X%02X", (arg & 0xFF), ((arg >> 8) & 0xFF), (arg >> 16) & 0xFF);
22. }
23. //+------------------------------------------------------------------+

Código 07

Observem que estamos criando uma pequena função na linha 19. Esta é bem simples de ser compreendida, com base no conhecimento mostrado nestes meus artigos, até o presente momento. Por conta disto, ao executarmos ela, teremos o retorno de uma string no formato hexadecimal. Mas este valor que será retornado estará conforme era esperado ser visto, quando fossemos analisar a cor como sendo RGB. Ao executarmos este código 07, iremos ver no terminal, algo parecido com a imagem logo abaixo.

Imagem 10

Agora veja uma coisa interessante aqui. Na primeira linha desta imagem 10, temos o valor da cor, sendo expressa. Mas o valor hexadecimal, não corresponde ao que esperávamos encontrar. Porém, ao olhar na última linha desta mesma imagem 10, podemos ver que ali sim, o valor é exatamente o que esperávamos encontrar. Isto quando estamos lendo a com como um RGB. Ou seja, aqueles valores que aparecem na primeira linha, são representados na ordem inversa no hexadecimal. Mas podemos girar eles, de forma que ficarão na ordem esperada. Um detalhe importante: Este valor visto na última linha da imagem 10, NÃO representa a cor que é informada na linha oito do código 07. Esta representação apenas apresenta o valor esperado devido aos valores vistos como retorno da função ColorToString. Então meu caro leitor, não confunda as coisas. Por isto mudei a cor para que a informação de fato fizesse sentido aqui. E pudesse ser explicada da maneira adequada.

Considerações finais

Neste artigo, foi mostrado a primeira parte de algo que é bem mais profundo e avançado do que possa parecer à primeira vista. Sei que muitos podem estar um tanto quanto confusos a respeito do que foi mostrado e exposto neste artigo. Mas garanto a você, meu caro e estimado leitor. Se você começar a estudar este material com bastante atenção, e praticar bastante a utilização do mesmo. Você conseguirá desenvolver aplicações bastante interessantes, pelo ponto de vista de comunicação como o usuário.

Apesar de o que foi visto aqui, ser apenas e tão somente um breve deslumbre do que podemos fazer. Você já terá bastante coisa para estudar e praticar. Então no próximo artigo, já poderemos ver um material um pouco mais avançado. E que sem ele, será difícil explicar outras questões que serão vistas depois. Assim, espero que você se divirta com os arquivos presentes no anexo e nos vemos no próximo artigo.