terça-feira, 30 de agosto de 2016

Operadores aritiméticos de atribuição

Primeiro analise os seguintes comandos abaixo:

int a = 10, b = 20, c = 30, d = 40, e = 50;

        a = a + 7;  ==>  a +=    7;
b = b - 4;  ==>   b -=    4;
        c = c * 5;  ==>   c *=     5;
        d = d / 3;  ==>   d /=     3;
e = e % 9; ==>   e %=   9;

É muito comum quando estamos programando atribuir um determinado valor
a uma variável, aliás, isto é fato, uma variável sem valor pode exibir lixo
na saída, bons compiladores detectam quando uma variável precisa ser inicializada.
Más o que ocorre é que muitas vêzes temos que atribuir o resultado de uma
expressão a uma variável, e se ela já possui um valor será atualizado com o
novo valor da expressão.
O que quero mostrar aqui é uma técnica adotada por C usando uma forma abreviada,
estas abreviações estão do lado direito das atribuições mostrada no exemplo acima.
Estas operações são equivalentes e cabe ao bom programador utilizá-las.
Os operadores +=, -=, *=, /=, e %= chamam-se operadores aritiméticos de atribuição
e o seu uso é fácil e recomendável.

Veja abaixo uma imagem exemplo do programa em execução:


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 DE ATRIBUIÇÃO" );
     got_color ( 2, 25, 3, 79, 0, 15 );
     textcolor ( LIGHTRED );
     gotoxy ( 22, 3 );
     printf ( "OPERADORES ARITIMÉTICOS DE ATRIBUIÇÃO" );
    int a = 10, b = 20, c = 30, d = 40, e = 50;
     a += 7;
     //a = a + 7 ;
     b -= 4;
     //b = b - 4 ;
     c *= 5;
     //c = c * 5 ;
     d /= 3;
     //d = d / 3 ;
     e %= 9;
     //e = e % 9 ;
     textcolor ( LIGHTBLUE );
     gotoxy ( 12, 5 );
     printf ( "Declaramos as variáveis e atribuímos um valor a cada uma" );
     textcolor ( BLACK );
     gotoxy ( 12, 7 );
     printf ( "int a = 10, b = 20, c = 30, d = 40, e = 50;" );
     textcolor ( LIGHTRED );
     gotoxy ( 12, 9 );
     printf ( "Atribuição normal%19sAtribuição abreviada", " ");//Formatação de saída com printf
     textcolor ( LIGHTBLUE );
     gotoxy ( 12, 11 );
     printf ( "a = a + 7;%14s==>%12sa += 7;", " ", " " );//Formatação de saída com printf
     textcolor ( LIGHTRED );
     printf ( " %d", a );
     textcolor ( LIGHTBLUE );
     gotoxy ( 12, 12 );
     printf ( "b = b - 4;%14s==>%12sb -= 4;", " ", " " );//Formatação de saída com printf
     textcolor ( LIGHTRED );
     printf ( " %d", b );
     textcolor ( LIGHTBLUE );
     gotoxy ( 12, 13 );
     printf ( "c = c * 5;%14s==>%12sc *= 5;", " ", " " );//Formatação de saída com printf
     textcolor ( LIGHTRED );
     printf ( " %d", c );
     textcolor ( LIGHTBLUE );
     gotoxy ( 12, 14 );
     printf ( "d = d / 3;%14s==>%12sd /= 3;", " ", " " );//Formatação de saída com printf
     textcolor ( LIGHTRED );
     printf ( " %d", d );
     textcolor ( LIGHTBLUE );
     gotoxy ( 12, 15 );
     printf ( "e = e %% 9;%14s==>%12se %%= 9;", " ", " " );//Formatação de saída com printf
     textcolor ( LIGHTRED );
     printf ( " %d", e );
     Sleep ( 1800 );
     textcolor ( LIGHTBLUE );
     gotoxy ( 26, 19 );
     printf ( "Por: " );
     textcolor ( LIGHTMAGENTA );
     printf ( "Samuel Lima" );
     textcolor ( BLACK );
     gotoxy ( 26, 20 );
     printf ( "sa_sp10@hotmail.com" );
     Sleep ( 1800 );
     textcolor ( LIGHTRED );
     gotoxy ( 37, 23 );
     printf ( "MUITO OBRIGADO" );
     getche ( );
}


domingo, 28 de agosto de 2016

Operadores aritiméticos - Incremento e decremento de Sufixo

Estes operadores são tão comuns que as vêzes até esquecemos que são operadores aritiméticos.
Para incrementar o valor de uma variável primeiro ela é declarada depois atribuímos à
variável o valor + 1, veja abaixo:
int a;
a = a + 1;
Más esta prática pode ser resumida já que temos uma abreviação simples pra isto,
que é utilizando o operador de incremento ++, veja abaixo:
a++;//Este é o operador de incremento de sufixo de C.
++a;//Este é o operador de incremento de prefixo de C.
Estes dois comandos acima incrementam a variável a por 1.
Só que temos que observar o modo como o C trata estes operadores de incremento
sufixo e prefixo, não são do mesmo modo.
Quando estamos usando o operador de incremento de sufixo, O C por padrão, usa
primeiro o valor da variável, em seguida vem a operação de incremento.
E quando estamos usando o operador de incremento de prefixo, o valor da variável
é incrementado primeiro, depois que vem o uso da variável.
Quando estamos programando, em algumas situações ocorre a necessidade de retirarmos
uma unidade de um determinado valor, e isto é perfeitamente possível usando o
operador de Decremento de C.
Para decrementar o valor de uma variável primeiro ela é declarada depois diminuímos à
variável o valor - 1, veja abaixo:
int a;
a = a - 1;
Más esta prática pode ser resumida já que temos uma abreviação simples pra isto,
que é utilizando o operador de decremento --, veja abaixo:
a--;//Este é o operador de Decremento de sufixo de C.
--a;//Este é o operador de Decremento de prefixo de C.
Estes dois comandos acima decrementam a variável a em menos 1.
Temos que observar o modo como o C trata estes operadores de decremento
sufixo e prefixo, não são do mesmo modo.
Quando estamos usando o operador de decremento de sufixo, O C por padrão, usa
primeiro o valor da variável, em seguida vem a operação de decremento.
E quando estamos usando o operador de decremento de prefixo, o valor da variável
é decrementado primeiro, depois que vem o uso da variável.

Para mostrar como funciona os operadores aritiméticos de incremento e decremento,
de sufixo criei este programa, que conta o número de ciclo dentro de um laço while();
No primeiro bloco a variável x é inicializada em zero, más a cada entrada dentro do
laço while(); é incrementada em  1 até que seu valor se iguale a macro tam.
No segundo bloco, à cada entrada dentro do laço while(); a variável x que é
inicializada pela macro tam é decrementada em 1, começando pelo valor da macro
e indo até 0 de onde vem a saída do programa.
Esta cadeia de ifs(); utilizadas nos dois blocos servem para posicionar junto com
gotoxy(); as impressões na tela do dos.

Veja abaixo uma imagem do programa em execução:


Veja abaixo o código do programa:
#include <stdio.h>
#include <conio.h>
#define tam 9
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 - INCREMENTO E DECREMENTO DE SUFIXO" );
     got_color ( 2, 25, 3, 79, 0, 15 );
     int i, x;
     textcolor ( LIGHTRED );
     gotoxy ( 12, 3 );
     printf ( "OPERADORES ARITIMÉTICOS - INCREMENTO E DECREMENTO DE SUFIXO" );
     textcolor ( LIGHTBLUE );
     gotoxy ( 22, 5 );
     printf ( "INCREMENTO" );
     x = 0;
     for ( i = 0; i < tam; i++ ) {
         do {
              x++;
              textcolor ( LIGHTRED );
              if ( x == 1 )
                   gotoxy ( 23, 7 );
              if ( x == 2 )
                   gotoxy ( 23, 8 );
              if ( x == 3 )
                   gotoxy ( 23, 9 );
              if ( x == 4 )
                   gotoxy ( 23, 10 );
              if ( x == 5 )
                   gotoxy ( 23, 11 );
              if ( x == 6 )
                   gotoxy ( 23, 12 );
              if ( x == 7 )
                   gotoxy ( 23, 13 );
              if ( x == 8 )
                   gotoxy ( 23, 14 );
              if ( x == 9 )
                   gotoxy ( 23, 15 );
              printf ( "%dº", x + 0 );
              textcolor ( BLACK );
              printf ( " Ciclo" );
              getche ( );
              break;
         } while ( 1 );
     }
     textcolor ( LIGHTBLUE );
     gotoxy ( 49, 5 );
     printf ( "DECREMENTO" );
     x = tam;
     for ( i = 0; i < tam; i++ ) {
         do {
              x--;
              textcolor ( LIGHTRED );
              if ( x == 0 )
                   gotoxy ( 50, 15 );
              if ( x == 1 )
                   gotoxy ( 50, 14 );
              if ( x == 2 )
                   gotoxy ( 50, 13 );
              if ( x == 3 )
                   gotoxy ( 50, 12 );
              if ( x == 4 )
                   gotoxy ( 50, 11 );
              if ( x == 5 )
                   gotoxy ( 50, 10 );
              if ( x == 6 )
                   gotoxy ( 50, 9 );
              if ( x == 7 )
                   gotoxy ( 50, 8 );
              if ( x == 8 )
                   gotoxy ( 50, 7 );
              if ( x == 9 )
                   gotoxy ( 50, 6 );
              printf ( "%dº", x + 1 );
              textcolor ( BLACK );
              printf ( " Ciclo" );
              getche ( );
              if ( x == 0 ) {
                   textcolor ( LIGHTBLUE );
                   gotoxy ( 31, 17 );
                   printf ( "Imprimido corretamente" );
                   Sleep ( 1800 );
                   textcolor ( LIGHTBLUE );
                   gotoxy ( 26, 19 );
                   printf ( "Por: " );
                   textcolor ( LIGHTMAGENTA );
                   printf ( "Samuel Lima" );
                   textcolor ( BLACK );
                   gotoxy ( 26, 20 );
                   printf ( "sa_sp10@hotmail.com" );
                   Sleep ( 1800 );
                   textcolor ( LIGHTRED );
                   gotoxy ( 37, 23 );
                   printf ( "MUITO OBRIGADO" );
                   getche ( );
              }
              break;
         } while ( 1 );
     }
     return 0;
}