Ferramentas do usuário

Ferramentas do site


operadores

Diferenças

Aqui você vê as diferenças entre duas revisões dessa página.


operadores [2023/09/12 16:14] (atual) – criada - edição externa 127.0.0.1
Linha 1: Linha 1:
 +====== Operadores ======
  
 +===== Operadores Aritméticos =====
 +
 +
 +^ Operador ^ Operação ^
 +|  +  | Adição |
 +|  -  | Subtração |
 +|  *  | Multiplicação |
 +|  /  | Divisão |
 +|  %  | Módulo (resto da divisão) |
 +
 +Todas estas operações exigem 2 operandos (números).
 +
 +===== Operadores Unários =====
 +
 +
 +^ Operador ^ Operação ^
 +|  ++  | Incremento |
 +|  --  | Decremento |
 +
 +A posição relativa destes operadores em relação a variável influencia o seu funcionamento. Se os operadores forem colocados antes da variável em uma expressão, inicialmente será efetuado o incremento e depois será utilizado este novo valor na expressão.
 +Se os operadores forem colocados após a variável, primeiro será utilizado o valor atual da variável na expressão, e após, será realizado o incremento ou decremento.
 +
 +<code c>
 +#include <stdio.h>
 +int main (void)
 +{
 +   int iValor_01 = 10, iValor_02 = 5, iValor_03 = 8;
 +   int iResultado;
 +
 +   iResultado = iValor_01++ + 9;         /* Retorna 10 para iValor_01 
 +                                            iResultador = 10 + 9
 +                                            iValor_01 = iValor_01 + 1 */
 +   printf("Resultado 1 %d\n", iResultado);
 +
 +   iResultado = --iValor_02 + 10;        /* iValor_02 = iValor_02 - 1
 +                                            iValor_02 fica com o valor 4
 +                                            iResultado = 4 + 10 */
 +   printf("Resultado 2 %d\n", iResultado);
 +
 +   iResultado = ++iValor_03 * ++iValor_03; /* iValor_03 = iValor_03 + 1
 +                                              Retorna 9 para iValor_03 
 +                                              iValor_03 = iValor_03 + 1
 +                                              Retorna 10 para iValor_03
 +                                              iResultado = 9 * 10 */
 +   printf("Resultado 3 %d\n", iResultado);
 +
 +   iResultado = iValor_01++ * iValor_01++;   /* Retorna 11 para iValor_01
 +                                                iValor_01 = iValor_01 + 1
 +                                                Retorna 12 para iValor_01
 +                                                iResultado = 11 * 12 
 +                                                iValor_01 = iValor_01 + 1 */
 +   printf("Resultado 4 %d\n", iResultado);
 +
 +   return 0;
 +}
 +</code>
 +
 +===== Operadores de Atribuição =====
 +
 +
 +^ Operador ^ Operação ^
 +|  +=  | Adição |
 +|  -=  | Subtração |
 +|  *=  | Multiplicação |
 +|  /=  | Divisão |
 +|  %=  | Módulo |
 +
 +Como é comum a atribuição aonde uma variável é somada ou diminuída de um valor e o resultado é atribuído à mesma variável, a Linguagem C disponibiliza uma maneira curta de realizar este tipo de operação.
 +
 +<code c>
 +#include <stdio.h>
 +
 +int main(void)
 +{
 +   int iValor_01, iValor_02, iValor_03, iValor_04;
 +
 +   iValor_01 = 5;
 +   iValor_02 = 9;
 +   iValor_03 = -2;
 +   iValor_04 = 24;
 +
 +   iValor_01 += 7; /* equivale a iValor_01 = iValor_01 + 7 */
 +
 +   iValor_02 -= (iValor_03*8); /* equivale a iValor_02 = iValor_02 - (iValor_03 *8) */
 +
 +   iValor_03 *= 4; /* equivale a iValor_03 = iValor_03 * 4 */
 +
 +   iValor_04 /= 6; /* equivale a iValor_01 = iValor_01 / 6 */
 +
 +   printf("\nValor 01 = %d", iValor_01); 
 +   printf("\nValor 02 = %d", iValor_02); 
 +   printf("\nValor 03 = %d", iValor_03); 
 +   printf("\nValor 04 = %d", iValor_04); 
 +   return 0;
 +
 +</code>
 +
 +===== Operadores Relacionais =====
 +
 +^ Operador ^ Operação ^
 +|  <  | Menor que |
 +|  >  | Maior que |
 +|  %%<=%%  | Menor ou igual a |
 +|  >=  | Maior ou igual a |
 +|  ==  | Igual |
 +|  !=  | Diferente |
 +
 +Os operadores relacionais servem para realizar a comparação de dois valores distintos. A implementação da Linguagem C retorna como resultado destas operações os seguintes valores:
 +   * 0 - Operação obteve o resultado falso;
 +   * 1 - Operação obteve o resultado verdadeiro.
 +
 +<code c>
 +#include <stdio.h>
 +
 +int main(void)
 +{
 +   printf("\n 5 > 7 ? A resposta é: %d", 5 > 7);
 +   printf("\n 5 > 4 ? A resposta é: %d", 5 > 4);
 +
 +   printf("\n 7 < 1 ? A resposta é: %d", 7 < 1);
 +   printf("\n 4 < 7 ? A resposta é: %d", 4 < 7);
 +  
 +   printf("\n 13 == 13 ? A resposta é: %d", 13 == 13 );
 +   printf("\n 24 == 22 ? A resposta é: %d", 24 == 22 );
 +
 +   printf("\n 13 != 13 ? A resposta é: %d", 13 != 13 );
 +   printf("\n 24 != 22 ? A resposta é: %d", 24 != 22 );
 +
 +   return 0;
 +}
 +</code>
 +
 +===== Prioridade de Avaliação =====
 +
 +^ Operadores ^ Prioridade ^
 +|  ++ --  | Prioridade mais alta |
 +|  * / %  | Prioridade média |
 +|  + -  | Prioridade baixa |
 +
 +Quando é utilizada uma série de operadores em uma expressão, deve-se sempre ter em mente a prioridade em que o compilador irá realizar estas operações.
 +
 +Os operadores unários têm a maior prioridade e serão executados por primeiro. Depois serão executadas todas as operações multiplicativas (*, / e %). Por último serão executadas as operações aditivas (+ e -).
 +
 +<code c>
 +#include <stdio.h>
 +int main(void)
 +{
 +   int iValor_01   = 10;
 +   int iResultado;
 +
 +   iResultado = 10 - 5 * 8; /* Ocorre a multiplicação (5*8=40) e depois subtrai  (10-40) = 30 */
 +   printf("Resultado 1 %d\n", iResultado);
 +
 +   iResultado = 7 * --iValor_01 - 4; /* Retorna 9 para iValor_01
 +                                        Realiza a multiplicação (7*9=63)
 +                                        Subtrai 4 (63-4 = 59) */
 +
 +   printf("Resultado 2 %d\n", iResultado);
 +   return 0;
 +}
 +</code>
 +
 +===== Operadores Lógicos =====
 +
 +^ Operadores ^ Prioridade ^
 +|  &&  | Operação lógica E |
 +|  %%||%%  | Operação lógica OU |
 +|  !  | Operação lógica negação |
 +
 +Os operadores lógicos consideram dois operandos como valores lógicos (verdadeiro e falso) e realizam a operação binária correspondente. A linguagem C considera como valor verdadeiro qualquer valor diferente de zero. O valor falso será indicado pelo valor zero.
 +Estas operações quando aplicadas irão retornar 1 ou zero, conforme o resultado seja verdadeiro ou falso.
 +
 +<code c>
 +#include <stdio.h>
 +int main(void)
 +{
 +   int iValor_01   = 10;
 +   int iResultado;
 +
 +   /* iValor_01 > 8 retorna verdadeiro ou seja 1
 +      iValor_01 != 6 retorna verdadeiro ou seja 1 */
 +   iResultado = (iValor_01 > 8) && (iValor_01 != 6); /* A expressão lógica 1 e 1 retorna 1. Lembrando que 0 representa o valor lógico falso 
 +                                                        e diferente de zero (1,2,3,etc..) representa o valor lógico verdadeiro. */
 +
 +   printf("Resultado: %d\n", iResultado);
 +   return 0;
 +}
 +</code>
 +
 +===== Assinalamento de Variáveis =====
 +
 +Para a linguagem C o assinalamento é considerado um operador. Isto significa que podem ser colocados assinalamentos dentro de qualquer comando que exija um valor qualquer.
 +Sempre que um assinalamento é efetuado, a Linguagem C retorna como resultado do assinalamento o valor que foi colocado em variáveis. Por isso pode-se utilizar este valor retornado pelo operador **''=''** e colocar como se fosse um novo assinalamento, concatenando os mesmos. Veja também [[variavel_definicao|definição de variáveis]].
 +
 +<code c>
 +#include <stdio.h>
 +int main(void)
 +{
 +   int  i,j,k,w;
 +
 +   i = j = k = 20;
 +
 +   printf ("Variavel i: %d\n", i );
 +   printf ("Variavel j: %d\n", j );
 +   printf ("Variavel k: %d\n", k );
 +
 +   printf ("Resultado da expressao: %d\n", w = 90);
 +   printf ("Variavel w: %d\n", w );
 +
 +   return 0;
 +}
 +</code>
 +
 +===== Parênteses e Colchetes como Operadores =====
 +Em C, parênteses são operadores que aumentam a precedência das operações dentro deles.
 +Colchetes realizam a indexação de [[vetor_matriz|matrizes]]. Dada uma matriz, a expressão dentro de colchetes provê um índice dentro dessa matriz.
 +
 +===== A precedência dos operadores em C =====
 +
 +^  ^ Operador ^
 +| Maior |  ( ) [ ] %%->%%  |
 +| |  ! ~ ++ -- -(tipo) * & sizeof  |
 +| |  * / %  |
 +| |  + -  |
 +| |  %%<< >>%%  |
 +| |  %%<<= >>=%%  |
 +| |  == !=  |
 +| |  &  |
 +| |  %%^%%  |
 +| |  %%|%%  |
 +| |  &&   |
 +| |  %%||%%  |
 +| |  ?  |
 +| |  = += -= *= /=  |
 +| Menor | , |
 +
 +
 +<code c>
 +/* operadores_parenteses.c */
 +
 +#include <stdio.h>
 +int main(void)
 +{
 +   int iVlr_a,iVlr_b;
 +   int iResultado;
 +
 +   /* Atribui 90 a variavel iVlr_a; 
 +      Realiza a multiplicacao (9*90=810); 
 +      Imprime o resultado (810) */
 +   printf("Resultado da expressao 1: %d\n", 9*(iVlr_a = 90));
 +   printf("Variavel iVlr_a: %d\n", iVlr_a );
 +
 +   /* Atribui 50 a variável iVlr_b.
 +      Realiza a multiplicação (20*50=1000).
 +      Atribui 1000 a variável resultado.
 +      Imprime o conteúdo da variável iResultado (1000). */
 +   printf("Resultado da expressao 2: %d\n", iResultado = (20*(iVlr_b=50)));
 +   printf("Variavel iVlr_b: %d\n", iVlr_b );
 +   printf("Variavel resultado: %d\n", iResultado );
 +   return 0;
 +}
 +</code>
 +
 +**Observação**: Embora a Linguagem C permita o assinalamento de variáveis no meio de expressões, seu uso não é recomendado pois dificulta o entendimento do programa.
 +
 +===== Operador & e * para Ponteiros =====
 +O primeiro operador de [[ponteiros|ponteiro]] é **''&''**. Ele é um operador unário que devolve o endereço na memória de seu operando. Por Exemplo:
 +
 +<code c>
 +m = &count;
 +</code>
 +
 +põe o endereço na memória da variável ''count'' em ''m''. Esse endereço é a posição interna da variável no computador e não tem nenhuma relação com o valor de ''count''. Você pode imaginar ''&'' como significando o **endereço de**.
 +
 +O segundo operador é **''*''**, que é o complemento de ''&''. O ''*'' é um operador unário que devolve o valor da variável localizada no endereço que o segue. Por exemplo, se ''m'' contém o endereço da variável ''count'':
 +
 +<code c>
 +q = *m;
 +</code>
 +
 +coloca o valor de ''count'' em ''q''. Pense no ''*'' como significando no **endereço de**.
 +
 +Observações:
 +   * Cuidado para não confundir ''*'' como multiplicação na utilização de ponteiros e vice-versa;
 +   * Cuidado para não confundir ''&'' como o operador relacional ''&&'' e vice-versa. 
 +
 +Veja também [[ponteiros|ponteiros em C]]
 +
 + --- //[[marcos@laureano.eti.br|Marcos Laureano]] 2009/05/08 11:22//