sábado, 27 de agosto de 2016

Operadores aritiméticos - Precedências

A face do céu lá fora está terrível,
tudo se tornou em preto e cinza,
e aqui do lado de dentro de minha sala,
escuto o uivado do vento gelado 
pelas frestas da janela me desmotivando a sair.
Vencido pelo medo do frio e pelo cansaço da semana,
resolvi ficar por aqui, e recordar um pouco,
o que já aprendemos em programação com linguagem C.

Familiarizar-se cedo com o uso dos operadores, são obrigações de todos
os interessados por linguagem C.
Ter domínio sobre as quatro classes de operadores é fundamental para
quem programa em C, isto é básico, não podemos pular.
Em posts anteriores já venho falando sobre operadores, e neste aqui,
concentro as atenções aos operadores aritiméticos.
Todos os operadores aritméticos trabalham sempre com dois operacionais
um na direita e outro na esquerda por isto são considerados binários.
Os cálculos de expressões aritiméticas em C obedece regras rígidas de
precedências de operadores para que os cáculos sejam exatos.
Más isto não é um problema para o programador já que o mesmo pode utilizar
parênteses para definir que estes cálculos devam ser realizados primeiro,
isto nada mais é do que o fato em que estamos alterando a ordem
das operações já que os parênteses tem o maior nível de precedência.
Basicamente os parênteses vem primeiro, se houver vários, os cálculos
acontece da esquerda para direita já que o nível de precedência são iguais.
depois vem: multiplicação, divisão, adição e subtração.

Os operadores aritiméticos são estes abaixo:

++ Incremento
-- Decremento
% Módulo da divisão (resto)
/ Divisão
* Multiplicação
+ Adição
- Subtração, também menos unário

                       OPERADORES ARITIMÉTICOS - PRECEDÊNCIAS

     Trocamos as chaves e os colchetes por parêntese e os de Vêzes x  por (*)
     e os de Dividir : por (/) já que não são operadores aritiméticos
     Observando a resolução percebemos logo que o C começou a resolver
     A expressão pelos parênteses internos.

                             Abaixo a expressão original

                 27 + { 14 + 3 x [ 100 : ( 18 – 4 x 2 ) + 7 ] } : 13

               Abaixo a expressão com os símbolos originais alterados

                 27 + ( 14 + 3 * ( 100 / ( 18 - 4 * 2 ) + 7 ) ) / 13

           1ª  27 + ( 14 + 3 * ( 100 / ( 18 - 8 ) + 7 ) ) / 13   ==> 32
           2ª  27 + ( 14 + 3 * ( 100 / 10 + 7 ) ) / 13           ==> 32
           3ª  27 + ( 14 + 3 * ( 10 + 7 ) ) / 13                 ==> 32
           4ª  27 + ( 14 + 3 * 17 ) / 13                         ==> 32
           5ª  27 + ( 14 + 51 ) / 13                             ==> 32
           6ª  27 + 65 / 13                                      ==> 32
           7ª  27 + 5                                            ==> 32

Na 1ª linha, dentro do parênteses mais interno temos dois operadores aritiméticos,
que são o de multiplicar (*) e o de menos. (-), note que o C já
começou resolvendo pelo de multiplicar já que ele tem a precedência
maior que o de menos, com isto, um parêntese é resolvido.

Na 2ª linha, dentro do parênteses mais interno temos dois operadores aritiméticos,
que são o de Dividir (/) e o de adição (+),  note que o C já
começou resolvendo pelo de Divisão já que ele tem a precedência
maior que o de adição, com isto, mais um parêntese é resolvido.

Na 3ª linha, dentro do parênteses mais interno temos um operador aritimético,
que é o de adição (+), note que o C já o resolveu, pois ele sempre começa por
parênteses mais interno, com isto, mais um parêntese foi resolvido.

Na 4ª linha, dentro do último parêntese temos dois operadores aritiméticos,
que são o de adição (+), e o de multiplicação note que o C já
começou resolvendo pelo de Multiplicação já que ele tem a precedência
maior que o de adição, o último parêntese ainda não foi resolvido.

Na 5ª linha, dentro do último parêntese temos um operador aritimético,
que é o de adição (+), porém, logo é resolvido por C, não esqueça
que o C sempre começa pelos parênteses, e quando tem vários, sempre elimina os mais
internos pela ordem.

Na ¨6ª linha, não temos mais parênteses más ainda temos dois operadores aritiméticos,
que são o de adição (+), e o de Divisão (/), tá mais que claro, que o C
resolveria primeiro o de Divisão já que a precedência dele é maior que o de adição.

Na 7ª linha temos o final da expressão com o resultado mais uma vez.


Veja abaixo o código do programa:

#include <stdio.h>
#include <conio.h>
void got_color ( int tam_lin_ini, int tam_lin_fim, int tam_ini_col,
         int tam_fim_col, int a, int b ) {
     int i, c;
     if ( a <= 16 ) {
         textcolor ( a );
     }
     if ( b <= 16 ) {
         textbackground ( b );
     }
     for ( i = tam_lin_ini; i < tam_lin_fim; i++ ) {
         for ( c = tam_ini_col; c < tam_fim_col; c++ ) {
              gotoxy ( c, i );
              printf ( " " );
         }
     }
}
int main ( ) {
     system ( "title OPERADORES ARITIMÉTICOS - PRECEDÊNCIAS" );
    got_color ( 2, 33, 3, 79, 0, 15 );
     textcolor ( LIGHTRED );
     gotoxy ( 24, 3 );
     printf ( "OPERADORES ARITIMÉTICOS - PRECEDÊNCIAS" );
     textcolor ( LIGHTBLUE );
     gotoxy ( 6, 5 );
     printf ("Trocamos as chaves e os colchetes por parêntese e os de Vêzes " "x" "  por (*) " );
     gotoxy ( 6, 6 );
     printf ("e os de Dividir " ":" " por (/) já que não são operadores aritiméticos" );
     gotoxy ( 6, 7 );
     printf ("Observando a resolução percebemos logo que o C começou a resolver" );
     gotoxy ( 6, 8 );
     printf ( "A expressão pelos parênteses internos." );
     gotoxy ( 30, 10 );
     textcolor ( LIGHTBLUE );
     printf ( "Abaixo a expressão original " );
     gotoxy ( 18, 12 );
     textcolor ( BLACK );
     printf ( "27 + { 14 + 3 x [ 100 : ( 18 – 4 x 2 ) + 7 ] } : 13" );
    gotoxy ( 16, 14 );
     textcolor ( LIGHTBLUE );
     printf ( "Abaixo a expressão com os símbolos originais alterados" );
     gotoxy ( 18, 16 );
     textcolor ( BLACK );
     printf ( "27 + ( 14 + 3 * ( 100 / ( 18 - 4 * 2 ) + 7 ) ) / 13" );
     gotoxy ( 12, 18 );
     textcolor ( LIGHTRED );
     printf ( "1ª" );
     textcolor ( LIGHTBLUE );
     printf ( "  27 + ( 14 + 3 * ( 100 / ( 18 - 8 ) + 7 ) ) / 13   ==> " );
     textcolor ( LIGHTRED );
     printf ( "%d", 27 + ( 14 + 3 * ( 100 / ( 18 - 8 ) + 7 ) ) / 13 );
    gotoxy ( 12, 19 );
     textcolor ( LIGHTRED );
     printf ( "2ª" );
     textcolor ( LIGHTBLUE );
     printf ( "  27 + ( 14 + 3 * ( 100 / 10 + 7 ) ) / 13           ==> " );
     textcolor ( LIGHTRED );
     printf ( "%d", 27 + ( 14 + 3 * ( 100 / 10 + 7 ) ) / 13 );
    gotoxy ( 12, 20 );
     textcolor ( LIGHTRED );
     printf ( "3ª" );
     textcolor ( LIGHTBLUE );
     printf ( "  27 + ( 14 + 3 * ( 10 + 7 ) ) / 13                 ==> " );
     textcolor ( LIGHTRED );
     printf ( "%d", 27 + ( 14 + 3 * ( 10 + 7 ) ) / 13 );
    gotoxy ( 12, 21 );
     textcolor ( LIGHTRED );
     printf ( "4ª" );
     textcolor ( LIGHTBLUE );
     printf ( "  27 + ( 14 + 3 * 17 ) / 13                         ==> " );
     textcolor ( LIGHTRED );
     printf ( "%d", 27 + ( 14 + 3 * 17 ) / 13 );
    gotoxy ( 12, 22 );
     textcolor ( LIGHTRED );
     printf ( "5ª" );
     textcolor ( LIGHTBLUE );
     printf ( "  27 + ( 14 + 51 ) / 13                             ==> " );
     textcolor ( LIGHTRED );
     printf ( "%d", 27 + ( 14 + 51 ) / 13 );
    gotoxy ( 12, 23 );
     textcolor ( LIGHTRED );
     printf ( "6ª" );
     textcolor ( LIGHTBLUE );
     printf ( "  27 + 65 / 13                                      ==> " );
     textcolor ( LIGHTRED );
     printf ( "%d", 27 + 65 / 13 );
    gotoxy ( 12, 24 );
     textcolor ( LIGHTRED );
     printf ( "7ª" );
     textcolor ( LIGHTBLUE );
     printf ( "  27 + 5                                            ==> " );
     textcolor ( LIGHTRED );
     printf ( "%d", 27 + 5 );
     Sleep ( 1800 );
     textcolor ( LIGHTBLUE );
     gotoxy ( 26, 26 );
     printf ( "Por: " );
     textcolor ( LIGHTMAGENTA );
     printf ( "Samuel Lima" );
     textcolor ( BLACK );
     gotoxy ( 26, 27 );
     printf ( "sa_sp10@hotmail.com" );
     Sleep ( 1800 );
     textcolor ( LIGHTRED );
     gotoxy ( 37, 31 );
     printf ( "MUITO OBRIGADO" );
     getche ( );
}


Nenhum comentário:

Postar um comentário

Observação: somente um membro deste blog pode postar um comentário.