Do básico ao intermediário: Precedência de operadores

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: Comando FOR, falamos sobre o que seria o básico do básico sobre o comando FOR. Com base naquele material, visto até o artigo anterior. Você meu caro leitor, já conseguirá criar uma bela quantidade de códigos em MQL5. Mesmo que sejam apenas aplicações simples e relativamente modestas. Mas ainda assim, já será algo que para muitos, é um grande motivo de orgulho e prazer.

Isto por que, mesmo que para outros programadores, pequenos trechos de código criados por um iniciante em programação. Onde o mesmo consegue fazer bolar uma solução para um problema que ele está tendo. De fato, é um motivo para se orgulhar. Porém, sem criar falsas esperanças e expectativas. Tudo que foi visto até este momento. Lhe permite, meu caro leitor, criar apenas código de script. Mesmo que sejam bem simples e sem muita interação. Ainda assim, se você está conseguindo fazer isto, com seu próprio esforço. Significa que está no caminho certo. E que já está conseguindo aplicar o conhecimento básico que foi mostrado até este presente momento.

Mas agora chegou a hora de falarmos de um outro assunto. Este irá nos permitir, progredir ainda mais na questão de como criar códigos, que venham a ser realmente mais interessantes. O que nós veremos aqui, são operadores. Apesar de já termos falados sobre isto antes. Agora iremos dar alguns passos a diante. Isto por que, o que foi visto anteriormente é algo bem básico e simples. Mas aqui iremos ver regras de precedência na prática, assim como o operador ternário. Que para muitos é algo bem confuso. Mas é muito útil em uma quantidade enorme de vezes. Nos poupando trabalho e esforço em certas operações de programação.

O pré-requisito para poder acompanhar o que será explicado neste artigo, é compreender sobre declaração e uso de variáveis em um código MQL5. Este assunto já foi abordado em artigos anteriores. Se você não tem este conhecimento, procure ler os artigos anteriores para conseguir entender este daqui. Dito isto podemos começar o que será o primeiro tópico deste artigo.

Regras de precedência

Entender e conhecer as regras de precedência é algo muito, mas muito importante mesmo. Já mencionei isto em um outro artigo. Porém aqui iremos aprofundar um pouco nesta questão.

Na documentação buscando regras de precedência, você verá um quadro com estas regras. No entanto, muita gente não consegue compreender de maneira adequada o que aquele quadro representa, ou o que aquelas informações de fato estão nos dizendo. Se este é o seu caso meu caro leitor. Não precisa ficar constrangido ou mesmo acanhado. É muito comum mesmo, ficamos um tanto confusos, no começo ao nos depararmos com este tipo de informação. Isto por que na escola, não aprendemos as coisas da mesma maneira que as usamos aqui, como programadores.

Apesar de em alguns casos, certas fatorações, feitas por alguns programadores serem um tanto quanto confusas de serem compreendidas. Elas de fato, muitas das vezes estão corretas. Mesmo que para nós, parecem estar dando um resultado diferente do esperado. Por conta disto, é de fato muito importante compreender as regras de precedência. Você não precisa tentar decorar elas. Com a prática e uso continuo, você acaba pegando o jeito. Mas o principal de tudo é: 

Se você não está entendendo, seu próprio código. Isto significa que outros também não entenderão.

Por isto, procure sempre pensar como outros poderiam pensar a respeito do que você está tentando fatorar. Então vamos começar pelo seguinte fato. A dita tabela ou quadro, mencionada no começo deste tópico, deverá ser lida da seguinte maneira: De cima para baixo. Sendo que os operadores que se encontram na parte superior, tem uma prioridade maior na execução. Conforme vamos descendo na tabela, a prioridade vai ficando cada vez menor.

Porém existe um pequeno detalhe a ser observado aqui. Para explicar isto, vamos ver a tabela na figura logo abaixo.

Imagem 01

Aqui você pode ver que os operadores estão sendo declarados em uma determinada ordem. Observar esta ordem é muito importante. Mas também pode notar que eles estão separados em termos de grupos. E é aqui, onde muita gente costuma ficar confusa. Isto porque, ao nos depararmos com alguns códigos, não sabemos qual será o resultado da fatoração se não entendermos esta separação mostrada na imagem 01. Esta separação é bem simples de entender e facilita bastante, para que você não precise decorar as regras de precedência. Primeiramente temos os operadores de referenciamento. Estes têm prioridade sobre todos os demais. Já que eles nos dizem como acessar um determinado elemento. Logo depois temos os operadores binários, ou de tipo. Neste caso, devemos sempre ler o código da direita para a esquerda. Mas como assim? Calma, meu caro leitor, nós vamos chegar lá. Irei explicar como você faz para ler o código nestes casos. Agora observe que é algo diferente dos operadores de referenciamento. Que teriam o código sendo lido da esquerda para a direita.

Eu sei, isto parece loucura. Neste momento você pode parar e pensar: "Cara por que complicam tanto?". Mas isto não é complicação meu caro leitor. Na prática você irá ver que isto faz todo o sentido. Sem ver isto sendo aplicado. De fato, parece ser a entrada de uma local onde só tem doido e maluco trabalhando. Mas, a na terceira divisão é que começamos a falar de coisas mais comuns a muita gente. Que são os primeiros operadores de funções aritmética. E neste caso a leitura do código deverá ser feita da esquerda para a direita. E assim vai até o final da imagem 01.

Agora vamos ver isto sendo aplicado na prática. Para isto, vamos usar alguns códigos bastante simples e bem diretos. Onde iremos simplesmente imprimir alguns valores. Esta é a parte fácil e divertida.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #define PrintX(X) Print("Factoring: { ", #X, " } is: ", X)
05. //+------------------------------------------------------------------+
06. void OnStart(void)
07. {
08.     char value = 9;
09. 
10.     PrintX(value);
11.     PrintX(++value * 5);
12.     PrintX(value);
13. }
14. //+------------------------------------------------------------------+

Código 01

Agora lhe pergunto meu caro leitor: Qual será o resultado impresso no terminal? Bem, sem o conhecimento sobre precedência de operadores, você poderia dizer que o resultado será 46, já que estamos multiplicando a variável cujo valor é nove com uma constante que vale cinco, e depois somamos uma unidade. Porém você está ERRADO. O resultado da execução deste código 01 é 50. Como mostrado na imagem abaixo.

Imagem 02

Achou isto confuso? Bem, então que tal, se fizermos uma nova brincadeira. Simplesmente tocando um simples detalhe no código. Como você pode ver logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #define PrintX(X) Print("Factoring: { ", #X, " } is: ", X)
05. //+------------------------------------------------------------------+
06. void OnStart(void)
07. {
08.     char value = 9;
09. 
10.     PrintX(value);
11.     PrintX(value++ * 5);
12.     PrintX(value);
13. }
14. //+------------------------------------------------------------------+

Código 02

O resultado deste código 02 é visto logo abaixo.

Imagem 03

Eu não disse no artigo anterior, que iriamos nos divertir bastante? Pois bem, eu poderia ficar brincando com estas regras de precedência por um bom tempo. Mostrando a você meu caro leitor, que na hora em que você estiver se achando, e imaginando estar preparado para a vida. Você de fato, se quer acabou de ficar em pé, e está tentando dar o que será o seu primeiro passo.

Eu sei, e precisa me dizer, que isto que está sendo mostrado parece insanidade. E que eu devo ser algum louco de pedra, que fugiu de algum local onde só trabalha malucos. Mas acredite meu caro leitor, a brincadeira apenas começou. E ainda estou me aquecendo. As coisas ficam ainda melhores. Então que tão um código ainda mais divertido? Podemos começar com este que você vê logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #define PrintX(X) Print("Factoring: { ", #X, " } is: ", X)
05. //+------------------------------------------------------------------+
06. void OnStart(void)
07. {
08.     char    v1 = 9,
09.             v2 = 5;
10. 
11.     PrintX(v1);
12.     PrintX(v2);
13.     PrintX(v1 & 1 * v2);
14.     PrintX((v1 & 1) * v2);
15. }
16. //+------------------------------------------------------------------+

Código 03

Isto sim é que é um código bonito. Algo maravilhoso, ainda mais se está sendo executado dentro de um laço. Observem o resultado que ele retorna, sendo mostrado logo abaixo.

Imagem 04

Agora confesse. Você assim como eu, está se divertindo vendo este tipo de coisa ocorrendo não é mesmo? Observe que a diferença aqui entre uma resposta e outra é justamente os parênteses que aparecem em uma expressão e não aparece em outra.

De fato, existe uma regra geral para se escrever este tipo de fatoração. Apesar de não ser uma regra explicita e escrita em pedra. Ela de fato existe de maneira implícita entre os programadores. E a regra diz o seguinte:

Quando for programar uma fatoração, procure separar os temos em níveis de execução. Fazendo a separação por meio de parênteses. Isto facilita a interpretação por parte de outros programadores.

De fato, mesmo quando o resultado é obvio, e segue a regra da precedência de operadores. Se você separar as coisas em termos de níveis de fatoração. Tornará bem mais simples entender que tipo de resultado você espera obter. Em alguns casos, nem mesmo o compilador consegue entender o que você pode estar querendo programar. Quer ver um exemplo disto? Pois bem, o código abaixo é um exemplo de código em que o resultado é completamente imprevisível. Já que nem o compilador consegue compreender o que deverá ser feito.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #define PrintX(X) Print("Factoring: { ", #X, " } is: ", X)
05. //+------------------------------------------------------------------+
06. void OnStart(void)
07. {
08.     char    v1 = 9,
09.             v2 = 5;
10. 
11.     PrintX(v1);
12.     PrintX(v2);
13.     PrintX(v1++ & 1 * v2 << 1);
14.     PrintX(v1);
15.     PrintX(v2);
16. }
17. //+------------------------------------------------------------------+

Código 04

Neste caso, quando você tentar compilar este código 04, o compilador irá dispara um alerta. Este pode ser visto logo abaixo.

Imagem 05

Note que apesar do alerta o compilador gerou o código. Porém existe um perigo muito grande aqui de que este código não venha a produzir um resultado correto, em certas situações. Portanto é um tanto temeroso que você venha a confiar cegamente neste código. Isto quando o compilador lança um alerta de possível falha que possa estar presente na fatoração. Neste tipo de caso, o uso de parênteses é imprescindível. Mas mesmo sem fazer isto, e usando somente as regras de precedência. Vamos ver se o resultado ainda assim seria correto, neste caso específico.

Para isto, executamos o código e o resultado é o que podemos ver logo na sequência.

Imagem 06

Aqui a resposta foi o valor oito. Mas será que este valor está de fato correto? Bem, para sabermos isto, precisamos fatorar na mão o que foi feito pelo código. Este tipo de coisa é muito comum em programação. Muitas vezes, e diferente do que muitos pensam. Um programador, não cria um código sem saber que tipo de resultado deverá ser gerado. Um bom programador, SEMPRE sabe qual o resultado da execução de seu código. Ele NUNCA cria algo cujo resultado ele não saiba de ante mão. Ou seja, um bom programador faz o que seria chamado de backtest de seu próprio código e depois faz o que é conhecido como ForwardTest, onde os resultados são analisados um a um. Somente depois de uma bateria de testes, é que ele passa a confiar um pouco mais no seu código. Mas nunca confia cegamente em todas as respostas. Ele sempre fica com um pé atras. Mas o motivo para se manter com um pé atras em uma dada resposta, será visto em outro artigo. Por hora vamos ver se a resposta correta para o código 04 de fato seria o valor oito.

Para saber se de fato a resposta está correta, precisamos pensar, como o compilador entendeu o que foi posto para ser fatorado. Como o compilador segue regras rígidas e estas estão sendo definidas na tabela ou quadro de precedência de operadores. Podemos fazer uma fatoração manual do cálculo da linha 13 e tentar ver se ele está de fato correto.

Para isto, precisamos começar pegando o operador de maior precedência primeiro. Este operador seria o ++, que está sendo aplicado na variável v1. Porém este operador trabalha da direita para a esquerda. Ou seja, neste caso a precedência dele será modificada sendo aplicado na variável v1 somente depois que o operador mais a direita for aplicado. No caso o operador mais a direita com uma precedência maior é o de multiplicação. Este se sobre sai em cima do operador de deslocamento para a esquerda e sobre o operador AND. Assim a primeira operação a ser feita é a multiplicação do valor 1 pelo valor de v2 uma vez feito isto, teremos o valor cinco como resposta. Agora aplicamos o operador de deslocamento para a esquerda. Este irá deslocar o valor cinco em um bit para a esquerda gerando assim o novo valor que é dez. Agora iremos efetuará a operação AND de v1 sobre este valor dez. Como v1 é igual a nove com esta operação AND sendo aplicada, teremos o valor oito. Logo depois, e somente agora, o valor de v1 será somado em uma unidade. Já que todos os operadores a direita foram executados. Por isto, temos o valor oito na fatoração e o valor dez para v1 logo depois da fatoração ter sido feita.

Você pode estar pensando: Saquei, é tudo muito simples claro e direto. Mas será mesmo assim meu caro leitor? Será que você realmente conseguiu entender como este procedimento funciona? Vejamos. Que tal me responder qual seria o resultado da fatoração que está sendo feita no código logo abaixo.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #define PrintX(X) Print("Factoring: { ", #X, " } is: ", X)
05. //+------------------------------------------------------------------+
06. void OnStart(void)
07. {
08.     char    v1 = 9,
09.             v2 = 5;
10. 
11.     PrintX(v1);
12.     PrintX(v2);
13.     PrintX(++v1 & 1 * v2 << 1);
14.     PrintX(v1);
15.     PrintX(v2);
16. }
17. //+------------------------------------------------------------------+

Código 05

Responda isto sem ficar na dúvida. Se você conseguir de fato responder isto corretamente. Ok, eu irei acreditar que você possa de fato estar entendendo como a precedência de operadores funciona. Mas mesmo assim, só de sacanagem, vou lhe mostrar uma resposta, e quero que você me diga se está certa ou errada.

Quando executei este código, encontrei a resposta que é vista logo abaixo.

Imagem 07

Agora me responda: Por que minha resposta deu dez e não oito? Existe um motivo para isto. E de fato está na regra de precedência de operadores. Bem, meu caro leitor, como eu não gosto de sacanear as pessoas. Vamos ver por que as respostas estão sendo diferentes. Mas para isto, vamos a um novo tópico. Pois não quero fritar nenhum cérebro neste artigo. Pois ainda falta um outro assunto para ser tratado aqui ainda.

BackTest e ForwardTest

A primeira coisa que você precisa entender meu caro leitor é o seguinte: Antes de programar algo, saiba qual é a resposta que o seu código irá lhe dar. Programar não é gerar um código para lhe responder algo que você não sabe a resposta. Programar é exatamente o contrário disto. Você cria um código para lhe dar uma resposta que você já sabe qual é. E neste caso, tanto no código 04 quanto no código 05, eu já sabia a resposta que deveria ser dada. Mesmo sabendo que poderia estar incorreta, justamente por conta do alerta do compilador. Mas como eu poderia saber a resposta antes mesmo de ter programador o código. Isto não faz sentido. Na verdade, muitos dizem para você programar para saber qual é a resposta, mas sabendo as regras de precedência, você consegue saber a resposta antes mesmo de ela ter lhe sido dada.

Para deixar isto bem claro, vamos fazer o seguinte: Como no anexo, irei disponibilizar estes códigos, você poderá fazer a mesma coisa que irei mostrar aqui. E desta forma irá compreender por que é importante saber a resposta antes mesmo de programar o código que irá lhe dar a resposta.

A verdadeira pergunta aqui é a seguinte: Qual resposta está correta: A que é vista na imagem 06 ou a que é vista na imagem 07? E se eu lhe dizer que ambas estão corretas. O que você me diria? Muito provavelmente que estou louco. Já que uma mesma expressão não pode dar duas respostas e ambas estarem corretas. Pois bem meu caro leitor, apesar de isto parecer loucura, o fato é que ambas respostas estão corretas. Porém, toda via e, entretanto, é bem mais provável que você estivesse procurando a resposta vista na imagem 07. Sendo que a resposta vista na imagem 06 seria apenas um efeito colateral de um mal uso da precedência de operadores. Se você mexer utilizar parênteses no código 04, a fim de corrigir a precedência dos operadores a resposta que será dada pelo código será exatamente a que é vista na imagem 07. E para isto, não precisa de muita coisa, basta ajustar as coisas para que o operador de incremento seja executado com uma prioridade maior. No caso do código 05, o fato do operador estar na frente da variável coloca ele acima do operador de multiplicação. Porém com foi explicado no tópico anterior, o fato de ele estar depois da variável, como acontece no código 04, faz com que o operador seja executado depois.

Não acredita? Que tal então fazermos um teste para comprovar isto? Este pode ser feito, ao modificar a linha 13 do código 04 para a linha que é vista logo abaixo.

    PrintX((v1++ & 1) * (v2 << 1));

E mesmo com esta mudança o compilador não irá mais dizer que o resultado não será confiável. Porém agora o mesmo código 04, que passou por esta simples mudança, irá nos dar a resposta vista na imagem 07. Isto é que torna certas coisas na programação tão complicadas. As pessoas muitas vezes estudam programação pelos motivos errados. Quando na verdade, o verdadeiro motivo é fazer com que o computador nos dê uma resposta já conhecida de maneira mais rápida. Quando precisarmos saber algo que já não temos o conhecimento da resposta. Podemos considerar a resposta do computador adequada. Mas existe um limite para este tipo de confiança. Porém dentro destes limites. A resposta fornecida depois de uma série de testes tanto com valores previamente conhecidos, com depois usando valores que sabemos calcular. Podemos finalmente dizer: MEU PROGRAMA CONSEGUE CALCULAR ISTO, OU AQUILO. Antes de todos estes testes é muito provável que seu código contenha erros, justamente por não ter sido devidamente testado.

Ok, neste ponto, vou deixar que você estude este tipo de coisa com calma e pense a este respeito. Porém antes de finalizar este artigo. Quero falar sobre uma outra coisa. Na verdade, um outro operador, que não se encaixa neste que vimos até o presente momento. Então vamos ao último tópico deste artigo.

Operador ternário

Este é o meu operador favorito. Quem de fato acompanha e procura estudar meus códigos, que podem ser vistos em diversos artigos aqui na comunidade. Já deve estar cansado de tanto me ver utilizando este operador. Mas por que ele é meu operador favorito? O motivo é simples: Com ele consigo criar expressões, sem a necessidade de utilizar o comando IF. Já que em muitos casos precisamos utilizar o comando IF para podermos modificar o fluxo de execução do código. Porém, toda via e, entretanto, existem casos em que podemos usar o operador ternário onde o comando IF não seria possível ser utilizado. Este operador ao meu ver é um operador de nível intermediário. Ou seja, é necessário ter um bom domínio sobre os demais operadores para de fato conseguir tirar todo proveito deste operador ternário. Além disto, é preciso compreender muito bem como a mudança de fluxo acontecerá neste operador. Pois ele quase nunca estará sendo utilizado de maneira isolada. Quase todas as vezes ele estará associado a um operador de atribuição ou um operador lógico. Por conta disto, irei apenas falar como ele deve ser lido. Mas por hora, não vamos usar ele ainda. Pelo menos vou tentar não usar, por enquanto.

Vamos ver um simples código onde este operador poderia estar sendo usado. Algo que de certa maneira daria para ser feito de outra forma. Mas o objetivo aqui é apenas a didática. Então ignorem o fato de poder usar outro método. Apenas tente entender o conceito utilizado aqui.

01. //+------------------------------------------------------------------+
02. #property copyright "Daniel Jose"
03. //+------------------------------------------------------------------+
04. #define PrintX(X) Print("Factoring: { ", #X, " } is: ", X)
05. //+------------------------------------------------------------------+
06. void OnStart(void)
07. {
08.     char    v1 = 9,
09.             v2 = 5;
10.             
11.     PrintX(v1);
12.     PrintX(v2);
13.     PrintX(v1 * ((v2 & 1) == true ? v2 - 1 : v2 + 1));
14.     PrintX(v2++);
15.     PrintX(v1 * ((v2 & 1) == true ? v2 - 1 : v2 + 1));
16.     PrintX(v1);
17.     PrintX(v2);
18. }
19. //+------------------------------------------------------------------+

Código 06

Quando este código 06 for executado, o resultado a ser visto é mostrado na imagem na sequência.

Imagem 08

Como este operador ternário, é algo bem confuso para muita gente. Principalmente os iniciantes. Vou explicar com calma o que está ocorrendo aqui. Porém, mesmo assim é necessário que você procure estudar todo este artigo. Para de fato assimilar o que está sendo mostrado aqui. Estude ele com calma e preste atenção ao que estou tentando explicar. Como o assunto é bem denso, pode ser que demore um pouco para você pegar o jeito da coisa.

Mas vamos voltar ao código 06. Muito deste código é simples de entender. Claro que temos uma macro, que ainda não falei como utilizar em seus códigos. Mas mesmo está macro aqui é bem simples de ser compreendida. Como ela foi utilizada em outros códigos aqui neste artigo. O que será explicado aqui serve para todos os demais códigos. A macro que está sendo definida na linha quatro, nos permite enviar algum tipo de informação para o terminal, com base no que está sendo usado no código. Mas como? Para fazer isto, enviamos a ela um argumento. Este argumento quando precedido de um jogo da velha ( # ), diz para o compilador pegar o argumento e o apresentar como ele foi implementado. Por conta disto é que podemos mostrar o cálculo que está sendo feito, assim como o valor de resultado e em alguns momentos o nome da variável utilizada. É uma boa forma de debugar certos tipos de código.

Bem, mas isto é somente uma parte da história. O que nos interessa de fato é: Como as linhas 13 e 15 funcionam. Esta sim é a parte que nos interessa. Pois ali temos o tal operador ternário. Para explicar isto de uma maneira simples, vamos pegar apenas uma das linhas como base de estudo. Já que a outra trabalha de uma forma muito parecida.

Sendo assim, vamos pegar a linha 13, e abrir a mesma de modo a não utilizar o operador ternário. Mas sim o comando IF. Mas por que usar o comando IF para explicar o operador ternário? O motivo é que o operador ternário, é um comando IF. Mas com a capacidade de ser uma expressão, podendo assim ser colocado em uma parte do código, como se fosse uma variável. Porém, apesar desta semelhança com o comando IF, o operador ternário, não substitui o comando IF. Já que este operador não consegue ter blocos de código sendo implementados dentro dele. Diferente do comando IF, que permite a utilização de blocos de código, porém não pode ser utilizado como sendo uma expressão de um comando.

Ok. Então traduzindo a linha 13, teríamos algo do tipo mostrado abaixo.

    if ((v2 & 1) == true) value = v1 * (v2 - 1);
        else value = v1 * (v2 + 1);
    Print("Factoring: { v1 * ((v2 & 1) == true ? v2 - 1 : v2 + 1) } is: ", value);

O único detalhe aqui é a variável value, que de fato não existe. Mas a estou utilizando apenas para explicar como as coisas são interpretadas pelo compilador. Então entenda a variável value, como sendo uma variável temporária, da qual você não terá nenhuma forma de acessar a mesma.

Assim, entendendo este conceito, fica simples de entender, como o compilador irá interpretar um operador ternário. Observe que ao utilizar o comando IF, todo o código se torna bem mais claro. Apesar de ser algo um tanto quanto impossível de ser feito em casos que de fato o operador ternário se faz necessário. Mas para fins didáticos está valendo. Assim como o comando Print que é visto neste pequeno fragmento de tradução. Este comando está fazendo a tradução do que seria o código da macro.

De fato, à primeira vista este tipo de coisa parece bem complicada de ser compreendida, assim de uma hora para outra. Ainda mais por que este tipo de codificação, como eu já disse, ao meu ver é uma implementação de nível intermediário. Então não tenha pressa meu caro leitor, em entender o que está acontecendo. Procure estudar e praticar as coisas aos poucos. Mas de qualquer maneira, uma vez que você tenha de fato compreendido que o operador ternário é um IF especial. Acredito que tudo ficará bem mais simples de ser assimilado conforme os próximos artigos forem sendo mostrados.

Considerações finais

Neste artigo apenas apresentei e tentei explicar algo que, sinceramente é um dos assuntos, mais complicados que existem em termos de programação. Isto se ficarmos apenas no campo da teoria. Na prática, este assunto sobre operadores é bem mais simples e fácil de ser compreendido e estudado. Isto por que, você vendo o que cada ação, ou forma de implementar algo, resultada no final. Torna bem mais simples compreender que programadores não tentam criar algo desconhecido. Todo e qualquer programa, tem como objetivo, nos responder algo que já conhecemos a princípio. Porém, conforme a aplicação vai sendo testada e ajustada, podemos depois de algum tempo, a utilizar para nos dar uma resposta mais rápida a respeito de alguma questão particular.

Então, para finalizar, deixo aqui um conselho: Estude e procure praticar bastante em diferentes tipos de desafio. Somente assim, você conseguirá dominar de maneira adequada, a forma de utilizar cada um dos operadores. Não imagine que apenas o fato de ter um conhecimento teórico sobre o assunto, já será suficiente. Pois não será. Quando o assunto envolve trabalhar com operadores, a experiência irá pesar muito mais que a teoria. Então comece a praticar.