Neste guia detalhado, discutiremos os operadores na programação C e seus tipos.
Operadores e seus tipos na programação em C
Operadores são os símbolos usados para realizar tarefas matemáticas específicas. Eles são usados para manipular os dados e variáveis. A seguir estão os diferentes tipos de operadores na programação C:
- Operadores aritméticos
- Operadores unários
- Operadores de atribuição
- Operadores lógicos ou booleanos
- Operadores relacionais
- Operadores condicionais
- Operadores bit a bit
1: Operadores Aritméticos
Estes são os operadores usados para executar funções matemáticas básicas como Adição, Subtração ou Multiplicação. Você pode usar esses operadores em quase todos os tipos de dados integrados da programação C. A seguir estão os operadores aritméticos usados na programação C:
| operadores | Funções |
| + | Adicionar 2 operandos |
| – | Subtrair 2 operandos |
| * | Multiplicar 2 operandos |
| / | Dividir 2 operandos |
| % | O operador de módulo dá o resto da divisão |
Exemplo
No exemplo abaixo, realizamos as operações aritméticas mencionadas acima na variável X e na variável Y. A variável X contém o valor 20 e Y contém o valor 5:
#include
int principal ( )
{
int x = vinte ;
int E = 5 ;
int resultado ;
resultado = x + E ;
printf ( 'A soma de X e Y é: %d \n ' , resultado ) ;
resultado = x - E ;
printf ( 'A subtração de X e Y é: %d \n ' , resultado ) ;
resultado = x * E ;
printf ( 'A multiplicação de X e Y é: %d \n ' , resultado ) ;
resultado = x / E ;
printf ( 'A divisão de X e Y é: %d \n ' , resultado ) ;
resultado = x % E ;
printf ( 'A divisão do módulo de X e Y é: %d \n ' , resultado ) ;
retornar 0 ;
}
2: Operadores Unários
Existem dois operadores unários exclusivos que são suportados apenas pela linguagem C, operadores de incremento ++ e decremento —. O operador de incremento adiciona 1 ao operando e o operador de decremento subtrai 1 do operando.
O operador de incremento é escrito como:
++ um ou um ++
O operador de decremento é:
-- um ou um --Se usarmos o operador de incremento e decremento como prefixo, ele primeiro adiciona ou subtrai o valor da variável e, em seguida, o resultado é atribuído à variável à esquerda. Se os operadores forem adicionados antes, primeiro retorna o valor original e depois o operando é adicionado ou subtraído por 1.
Exemplo
Abaixo, atribuímos valores a duas variáveis a e b e aplicamos operadores de incremento e decremento a elas:
#includeint principal ( )
{
int a = quinze , b = 10 ;
printf ( '++a = %d \n ' , ++ a ) ;
printf ( 'a++ = %d \n ' , a ++ ) ;
retornar 0 ;
}
3: Operador de Atribuição
Um operador de atribuição (=) é usado para atribuir o valor à variável no programa. Abaixo estão os operadores de atribuição mencionados:
| operadores | Função |
| = | Atribuir os valores ao operando |
| += | Some o valor do operando presente à direita ao operando esquerdo |
| -= | Subtraia o valor do operando direito do operando esquerdo |
| *= | Multiplique o valor do operando direito pelo operando esquerdo |
| /= | Divide o valor do operando direito para o operando esquerdo |
| %= | Pegue o módulo de dois valores e atribua o valor ao operando esquerdo |
Exemplo
Demonstramos o funcionamento dos operadores de atribuição nos dois operandos X e Y no exemplo abaixo:
#includeint principal ( )
{
int x = 10 ;
int resultado ;
resultado = x ;
printf ( 'Valor do resultado = %d \n ' , resultado ) ;
resultado += x ;
printf ( 'Valor do resultado = %d \n ' , resultado ) ;
resultado -= x ;
printf ( 'Valor do resultado = %d \n ' , resultado ) ;
resultado *= x ;
printf ( 'Valor do resultado = %d \n ' , resultado ) ;
resultado /= x ;
printf ( 'Valor do resultado = %d \n ' , resultado ) ;
retornar 0 ;
}
4: Operadores Relacionais
Os operadores relacionais são usados na programação C para verificar a relação entre duas variáveis. Pode ser usado para comparar os preços dos itens ou a idade de duas pessoas A seguir estão os operadores relacionais usados na programação C:
| operadores | Funções |
| == | Igual a |
| > | Maior que |
| < | Menor que |
| >= | Maior que igual a |
| <= | menor que igual a |
| != | Não igual a |
Exemplo
O exemplo abaixo mostra o funcionamento dos operadores relacionais na programação C:
#includeint principal ( )
{
int a = 9 ;
int b = 10 ;
printf ( '%d == %d é %d \n ' , a , b , a == b ) ;
printf ( '%d > %d é %d \n ' , a , b , a > b ) ;
printf ( '%d < %d é %d \n ' , a , b , a < b ) ;
printf ( '%d != %d é %d \n ' , a , b , a != b ) ;
printf ( '%d >= %d é %d \n ' , a , b , a >= b ) ;
printf ( '%d <= %d é %d \n ' , a , b , a <= b ) ;
retornar 0 ;
}
5: Operadores Lógicos
Existem quatro operadores lógicos suportados pela linguagem C:
| operadores | Função |
| AND Lógico (&&) | Verdadeiro somente se todas as condições satisfizerem |
| OU Lógico (||) | Se apenas uma condição satisfizer o resultado é verdadeiro |
| NÃO Lógico (!) | Se Operando for 0 o resultado é verdadeiro |
| Bit a bit NOT (~). | Inverte todos os bits do operando |
Exemplo
O código de exemplo abaixo explica o funcionamento dos operadores lógicos em C:
#includeint principal ( )
{
int x = 10 , E = 4 , COM = 10 , resultado ;
resultado = ( x == E ) && ( COM > E ) ;
printf ( '(X == Y) && (Z > Y) é %d \n ' , resultado ) ;
resultado = ( x == E ) && ( COM < E ) ;
printf ( '(X == Y) && (Z < Y) é %d \n ' , resultado ) ;
resultado = ( x == E ) || ( COM < E ) ;
printf ( '(X == Y) || (Z < Y) é %d \n ' , resultado ) ;
resultado = ( x != E ) || ( COM < E ) ;
printf ( '(X != Y) || (Z < Y) é %d \n ' , resultado ) ;
resultado = ! ( x != E ) ;
printf ( '!(X != Y) é %d \n ' , resultado ) ;
resultado = ! ( x == E ) ;
printf ( '!(X == Y) é %d \n ' , resultado ) ;
resultado = ! ( x > E ) ;
printf ( '!(X > Y) é %d \n ' , resultado ) ;
retornar 0 ;
}
6: Operadores Condicionais
O operador condicional em C também é conhecido como operador ternário porque requer três operandos – a condição, instrução 1 e instrução 2. Ele avalia a condição e retorna a instrução 1 ou a instrução 2, dependendo do resultado de uma determinada condição que pode ser verdadeira ou falsa
Doença ? Declaração 1 : Declaração 2- Doença: Uma expressão booleana que verifica se é verdadeira ou falsa.
- Declaração 1: Uma expressão que é avaliada se a condição for verdadeira.
- Declaração 2: Uma expressão que é avaliada se a condição for falsa.
Exemplo
No exemplo abaixo, atribuí o valor ao número e apliquei a condição, se a condição for verdadeira, a declaração 1 será a saída e se a condição for falsa, a declaração dois será a saída:
#includeint principal ( )
{
int número = 10 ;
( número < vinte ) ? ( printf ( 'É menos do que o número 20!' ) ) : ( printf ( 'É maior que o número 20!' ) ) ;
retornar 0 ;
}
7: Operadores bit a bit
Operadores bit a bit em C manipulam dados no nível de bit, o que significa que eles operam em bits individuais dentro de tipos de dados como inteiros. Eles não podem ser aplicados ao double e ao float e são usados para testar os bits e deslocá-los para a direita ou para a esquerda.
Os operadores bit a bit na programação C são fornecidos na tabela abaixo:
| operadores | Função |
| & | E bit a bit |
| | | OU bit a bit |
| ^ | OU exclusivo bit a bit |
| << | Deslocar para a esquerda |
| >> | Deslocar para a direita |
| ~ | complemento de um |
Exemplo
O exemplo a seguir mostra um programa C que usa operadores bit a bit:
#includeint principal ( ) {
int a = 13 ; // binário 1101
int b = 7 ; // binário 0111
int resultado ;
// bit a bit AND
resultado = a & b ; // 1101 & 0111 = 0101 (decimal 5)
printf ( 'a & b = %u \n ' , resultado ) ;
// bit a bit OR
resultado = a | b ; // 1101 | 0111 = 1111 (decimal 15)
printf ( 'a | b = %u \n ' , resultado ) ;
// XOR bit a bit
resultado = a ^ b ; // 1101 ^ 0111 = 1010 (decimal 10)
printf ( 'a ^ b = %u \n ' , resultado ) ;
// Deslocamento à esquerda bit a bit
resultado = a << 2 ; // 1101 << 2 = 110100 (decimal 52)
printf ( 'a << 2 = %u \n ' , resultado ) ;
// Deslocamento bit a bit para a direita
resultado = a >> 2 ; // 1101 >> 2 = 0011 (decimal 3)
printf ( 'a >> 2 = %u \n ' , resultado ) ;
// Bit a bit NOT
resultado = ~a ; // ~1101 = 0010 (representação do complemento decimal de 2 de -14)
printf ( '~a = %d \n ' , resultado ) ;
retornar 0 ;
}
Observação: Os operadores bit a bit são usados para executar tarefas no nível de bit, o que significa que operam em bits individuais dentro de um número binário. Os operadores booleanos, por outro lado, são usados para realizar operações em valores lógicos. Eles operam em valores booleanos (verdadeiro/falso ou 1/0) e são comumente usados em processos de tomada de decisão ou declarações condicionais.
Conclusão
Um operador é um símbolo que instrui o compilador a realizar certas funções. A linguagem C possui vários operadores integrados, incluindo aritmético, unário, atribuição, lógico, relacional, condicional, booleano e bit a bit. Nós os discutimos em detalhes e os demonstramos com a saída de exemplo. Leia a seção acima do guia para obter informações detalhadas sobre esses operadores.