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:
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.