English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Um operador é um símbolo que informa ao compilador para executar uma operação matemática ou lógica específica. O linguagem C possui uma variedade de operadores e oferece os seguintes tipos de operadores:
operadores aritméticos
operadores de relação
Operadores lógicos
Operadores de operação de bits
Operadores de atribuição
operadores variados
Este capítulo apresentará os operadores aritméticos, operadores de relação, operadores lógicos, operadores de bits, operadores de atribuição e outros operadores um por um.
A tabela a seguir mostra todos os operadores aritméticos suportados pelo linguagem C. Suponha a variável A O valor é 10Variável B O valor é 2
| operador | Descrição | Exemplo |
|---|---|---|
| + | somar os dois operandos | A + B resultará em 30 |
| - | subtrair o segundo operando do primeiro | A - B resultará em -10 |
| * | multiplicar os dois operandos | A * B resultará em 200 |
| / | divisor por dividendo | B / A resultará em 2 |
| % | operador de módulo, resto da divisão inteira | B % A resultará em 0 |
| ++ | operador de incrementio, valor inteiro aumenta 1 | A++ Será 11 |
| -- | operador de decremento, valor inteiro diminui 1 | A-- Será 9 |
Veja o exemplo a seguir para entender todos os operadores aritméticos disponíveis no linguagem C:
#include <stdio.h>
int main()
{
int a = 21;
int b = 10;
int c;
c = a + b;
printf("Linha 1 - c = %d
c = a - b;
printf("Linha 2 - c = %d
c = a * b;
printf("Linha 3 - c = %d
c = a / b;
printf("Linha 4 - c = %d
c = a % b;
printf("Linha 5 - c = %d
c = a++; // atribuição e depois adição 1 onde c é 21onde a é 22
printf("Linha 6 - c = %d
c = a--; // atribuição e depois subtração 1 onde c é 22 onde a é 21
printf("Linha 7 - c = %d
}Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:
Linha 1 - O valor de c é 31 Linha 2 - O valor de c é 11 Linha 3 - O valor de c é 210 Linha 4 - O valor de c é 2 Linha 5 - O valor de c é 1 Linha 6 - O valor de c é 21 Linha 7 - O valor de c é 22
O exemplo a seguir demonstra a++ com ++a diferença:
#include <stdio.h>
int main()
{
int c;
int a = 10;
c = a++;
printf("primeiro atribuição e depois operação:\n");
printf("Linha 1 - c = %d
printf("Linha 2 - o valor de a é %d\n", a);
a = 10;
c = a--;
printf("Linha 3 - c = %d
printf("Linha 4 - o valor de a é %d\n", a);
printf("primeiro operação e depois atribuição:\n");
a = 10;
c = ++a;
printf("Linha 5 - c = %d
printf("Linha 6 - o valor de a é %d\n", a);
a = 10;
c = --a;
printf("Linha 7 - c = %d
printf("Linha 8 - o valor de a é %d\n", a);
}O resultado da execução do programa acima é:
primeiro atribuição e depois operação: Linha 1 - O valor de c é 10 Linha 2 - o valor de a é 11 Linha 3 - O valor de c é 10 Linha 4 - o valor de a é 9 primeiro operação e depois atribuição: Linha 5 - O valor de c é 11 Linha 6 - o valor de a é 11 Linha 7 - O valor de c é 9 Linha 8 - o valor de a é 9
A tabela a seguir mostra todos os operadores de relação suportados pelo linguagem C. Suponha a variável A O valor é 10Variável B O valor é 2
| operador | Descrição | Exemplo |
|---|---|---|
| 0, então: | == | Verifica se os valores dos operandos são iguais, se forem, a condição é verdadeira. |
| (A == B) é falso. | != | Verifica se os valores dos operandos são iguais, se não forem, a condição é verdadeira. |
| (A != B) é verdadeiro. | > | Verifica se o valor do operando esquerdo é maior que o valor do operando direito, se for, a condição é verdadeira. |
| (A > B) é falso. | < | Verifica se o valor do operando esquerdo é menor que o valor do operando direito, se for, a condição é verdadeira. |
| (A < B) é verdadeiro. | >= | Verifica se o valor do operando esquerdo é maior ou igual ao valor do operando direito, se for, a condição é verdadeira. |
| (A >= B) é falso. | <= | Verifica se o valor do operando esquerdo é menor ou igual ao valor do operando direito, se for, a condição é verdadeira. |
(A <= B) é verdadeiro.
#include <stdio.h>
int main()
{
int a = 21;
int b = 10;
int c;
Veja o exemplo a seguir para entender todos os operadores de relação disponíveis no C:
{
printf("Linha 1 - if (a == b)
}
else
{
printf("Linha 1 - a é igual a b
}
a não é igual a b
{
printf("Linha 2 - if (a < b)
}
else
{
printf("Linha 2 - a é menor que b
}
a não é menor ou igual a b
{
printf("Linha 3 - if (a > b)
}
else
{
printf("Linha 3 - a é maior que b
}
/* Mudar os valores de a e b */
a = 5;
b = 20;
a não é maior ou igual a b
{
printf("Linha 4 - a é menor ou igual a b
}
if (b >= a)
{
printf("Linha 5 - b é maior ou igual a a
}
}Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:
Linha 1 - a não é igual a b Linha 2 - a não é menor ou igual a b Linha 3 - a é maior que b Linha 4 - a é menor ou igual a b Linha 5 - b é maior ou igual a a
A tabela a seguir mostra todos os operadores lógicos de relação suportados pelo C. Supondo a variável A O valor é 1Variável B Se o valor for 0, então:
| operador | Descrição | Exemplo |
|---|---|---|
| && | Chamado de operador lógico e. Se ambos os operandos forem não nulos, a condição é verdadeira. | (A && B) é falso. |
| || | Chamado de operador lógico ou. Se qualquer um dos operandos for não nulo, a condição é verdadeira. | (A || B) é verdadeiro. |
| ! | Chamado de operador lógico não. Usado para inverter o estado lógico do operando. Se a condição for verdadeira, o operador lógico não a tornará falsa. | !(A && B) é verdadeiro. |
Veja o exemplo a seguir para entender todos os operadores lógicos disponíveis no C:
#include <stdio.h>
int main()
{
int a = 5;
int b = 20;
int c;
if (a && b)
{
printf("Linha 1 - Condição verdadeira
}
if (a || b)
{
printf("Linha 2 - Condição verdadeira
}
/* Mudar os valores de a e b */
a = 0;
b = 10;
if (a && b)
{
printf("Linha 3 - Condição verdadeira
}
else
{
printf("Linha 3 - Condição falsa
}
if (! (a && b))
{
printf("Linha 4 - Condição verdadeira
}
}Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:
Linha 1 - Condição verdadeira Linha 2 - Condição verdadeira Linha 3 - Condição falsa Linha 4 - Condição verdadeira
Os operadores de operação de bits agem sobre os bits, executando operações bit a bit. A tabela verdade dos operadores de operação de bits é como segue:
| p | q | p & q | p | q | p ^ q |
|---|---|---|---|---|
| 0 | 0 | 0 | 0 | 0 |
| 0 | 1 | 0 | 1 | 1 |
| 1 | 1 | 1 | 1 | 0 |
| 1 | 0 | 0 | 1 | 1 |
Supondo se A = 60, e B = 13Agora, representados em formato binário, eles são como follows:
A = 0011 1100
B = 0000 1101
-----------------
A&B = 0000 1100
A|B = 0011 1101
A^B = 0011 0001
~A = 11000011
A tabela a seguir mostra os operadores de bit suportados pelo C. Supondo que a variável A O valor é 60, variável B O valor é 13Portanto:
| operador | Descrição | Exemplo |
|---|---|---|
| & | A operação de AND bit a bit realiza uma operação de 'AND' de bits binários. Regras de operação: 0&0=0; 0&1=0; 1&0=0; 1&1=1; | (A & B) será 120000 1100 |
| | | O operador de OR bit a bit realiza uma operação de 'OR' de bits binários. Regras de operação: 0|0=0; 0|1=1; 1|0=1; 1|1=1; | (A | B) será 610011 1101 |
| ^ | O operador de XOR realiza uma operação de 'XOR' de bits binários. Regras de operação: 0^0=0; 0^1=1; 1^0=1; 1^1=0; | (A ^ B) será 490011 0001 |
| ~ | O operador de negação inversa realiza uma operação de 'inversão' de bits binários. Regras de operação: ~1=0; ~0=1; | (~A) será -61Ou seja 11000011O valor de um número binário signed é |
| << | Operador de deslocamento à esquerda binário. Desloca todos os bits de um objeto de operação para a esquerda por alguns bits (os bits à esquerda são descartados e os bits à direita são preenchidos com 0). | A << 2 Será 240, ou seja 1111 0000 |
| >> | Operador de deslocamento à direita binário. Desloca todos os bits de um número para a direita por alguns bits, os números positivos são preenchidos à esquerda com 0 e os números negativos são preenchidos à esquerda com1O bits à direita são descartados. | A >> 2 Será 150000 1111 |
Veja o exemplo a seguir para entender todos os operadores de bit disponíveis no C:
#include <stdio.h>
int main()
{
unsigned int a = 60; /* 60 = 0011 1100 */
unsigned int b = 13; /* 13 1101 */
int c = 0;
c = a & b; /* 12 1100 */
printf("Linha 1 - c = %d
c = a | b; /* 61 = 0011 1101 */
printf("Linha 2 - c = %d
c = a ^ b; /* 49 = 0011 0001 */
printf("Linha 3 - c = %d
c = ~a; /*-61 = 1100 0011 */
printf("Linha 4 - c = %d
c = a << 2; /* 240 = 00 1111 0000 */
printf("Linha 5 - c = %d
c = a >> 2; /* 15 1111 */
printf("Linha 6 - c = %d
}Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:
Linha 1 - O valor de c é 12 Linha 2 - O valor de c é 61 Linha 3 - O valor de c é 49 Linha 4 - O valor de c é -61 Linha 5 - O valor de c é 240 Linha 6 - O valor de c é 15
A tabela a seguir lista os operadores de atribuição suportados pelo C:
| operador | Descrição | Exemplo |
|---|---|---|
| = | O operador de atribuição simples atribui o valor do operando direito ao operando esquerdo | C = A + B atribuirá A + O valor de B é atribuído a C |
| += | O operador de adição e atribuição atribui o resultado da adição do operando direito pelo operando esquerdo ao operando esquerdo | C += A é equivalente a C = C + A |
| -= | O operador de subtração e atribuição atribui o resultado da subtração do operando esquerdo pelo operando direito ao operando esquerdo | C -= A é equivalente a C = C - A |
| *= | O operador de multiplicação e atribuição atribui o resultado da multiplicação do operando direito pelo operando esquerdo ao operando esquerdo | C *= A é equivalente a C = C * A |
| /= | O operador de divisão e atribuição atribui o resultado da divisão do operando esquerdo pelo operando direito ao operando esquerdo | C /= A é equivalente a C = C / A |
| %= | O operador de módulo e atribuição atribui o módulo dos dois operandos ao operando esquerdo | C %= A é equivalente a C = C % A |
| <<= | Operador de deslocamento à esquerda e atribuição | C <<= 2 Equivalente a C = C << 2 |
| >>= | Operador de deslocamento à direita e atribuição | C >>= 2 Equivalente a C = C >> 2 |
| &= | Operador de e bit a bit e atribuição | C &= 2 Equivalente a C = C & 2 |
| ^= | Operador de xor bit a bit e atribuição | C ^= 2 Equivalente a C = C ^ 2 |
| |= | Operador de ou bit a bit e atribuição | C |= 2 Equivalente a C = C | 2 |
Veja o exemplo a seguir para entender todos os operadores de atribuição disponíveis no C:
#include <stdio.h>
main()
{
int a = 21;
int c;
c = a;
printf("Linha 1 - Exemplo do operador =, o valor de c é = %d\n", c );
c += a;
printf("Linha 2 - +Exemplo do operador =, o valor de c é = %d\n", c );
c -= a;
printf("Linha 3 - -Exemplo do operador =, o valor de c é = %d\n", c );
c *= a;
printf("Linha 4 - *Exemplo do operador =, o valor de c é = %d\n", c );
c /= a;
printf("Linha 5 - /Exemplo do operador =, o valor de c é = %d\n", c );
c = 200;
c %=
printf("Linha 6 - Exemplo do operador %=, o valor de c é = %d\n", c );
c <<= 2;
printf("Linha 7 - Exemplo do operador <<=, o valor de c é = %d\n", c );
c >>= 2;
printf("Linha 8 - Exemplo do operador >=, o valor de c é = %d\n", c );
c &= 2;
printf("Linha 9 - Exemplo do operador &=, o valor de c é = %d\n", c );
c ^= 2;
printf("Linha 10 - Exemplo do operador ^=, o valor de c é = %d\n", c );
c |= 2;
printf("Linha 11 - c |=, o valor de c é = %d\n", c );
}Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:
Linha 1 - Exemplo do operador =, o valor de c é = 21 Linha 2 - +Exemplo do operador =, o valor de c é = 42 Linha 3 - -Exemplo do operador =, o valor de c é = 21 Linha 4 - *Exemplo do operador =, o valor de c é = 441 Linha 5 - /Exemplo do operador =, o valor de c é = 21 Linha 6 - Exemplo do operador %=, o valor de c é = 11 Linha 7 - Exemplo do operador <<=, o valor de c é = 44 Linha 8 - Exemplo do operador >=, o valor de c é = 11 Linha 9 - Exemplo do operador &=, o valor de c é = 2 Linha 10 - Exemplo do operador ^=, o valor de c é = 0 Linha 11 - Exemplo do operador |=, o valor de c é = 2
A tabela a seguir lista outros operadores importantes suportados pelo C, incluindo sizeof e ? :.
| operador | Descrição | Exemplo |
|---|---|---|
| sizeof() | Retornar o tamanho da variável. | sizeof(a) retornará 4onde a é um inteiro. |
| & | Retornar o endereço da variável. | &a; fornecerá o endereço real da variável. |
| * | Apontar para uma variável. | *a; apontará para uma variável. |
| ? : | Expressão condicional | Se a condição for verdadeira? então o valor é X : caso contrário o valor é Y |
Veja o exemplo a seguir para entender todos os operadores de miscelânea disponíveis no C:
#include <stdio.h>
int main()
{
int a = 4;
short b;
double c;
int* ptr;
/* Exemplo do operador sizeof */
printf("Linha 1 - O tamanho do variável a é = %lu\n", sizeof(a) );
printf("Linha 2 - tamanho da variável b = %lu\n", sizeof(b));
printf("Linha 3 - tamanho da variável c = %lu\n", sizeof(c));
/* & e * exemplo de operador */
ptr = &a; /* 'ptr' agora contém o endereço de 'a' */
printf("o valor de a é %d\n", a);
printf("*ptr é %d\n", *ptr);
/* exemplo de operador ternário */
a = 10;
b = (a == 1) ? 20: 30;
printf("o valor de b é %d\n", b);
b = (a == 10) ? 20: 30;
printf("o valor de b é %d\n", b);
}Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:
Linha 1 - tamanho da variável a = 4 Linha 2 - tamanho da variável b = 2 Linha 3 - tamanho da variável c = 8 o valor de a é 4 *ptr é 4 o valor de b é 30 o valor de b é 20
A prioridade dos operadores determina como os itens de uma expressão são combinados. Isso afeta como uma expressão é calculada. Alguns operadores têm prioridade mais alta do que outros, por exemplo, os operadores de multiplicação e divisão têm prioridade mais alta do que os de adição e subtração.
por exemplo x = 7 + 3 * 2aqui, x é atribuído a 13, não 20, porque o operador * com + prioridade, então primeiro calcula-se a multiplicação 3*2então mais 7.
A tabela a seguir lista os operadores por prioridade de operação, dos mais altos para os mais baixos, com os operadores de maior prioridade no topo da tabela e os de menor prioridade no fundo. Em uma expressão, os operadores de maior prioridade são calculados primeiro.
| categoria | operador | combinação |
|---|---|---|
| pós-fixo | () [] -> . ++ - - | da esquerda para a direita |
| unário | + - ! ~ ++ - - (type)* & sizeof | da direita para a esquerda |
| multiplicação-divisão | * / % | da esquerda para a direita |
| soma-subtração | + - | da esquerda para a direita |
| deslocamento | << >> | da esquerda para a direita |
| relacional | < <= > >= | da esquerda para a direita |
| igual | == != | da esquerda para a direita |
| bit e AND | & | da esquerda para a direita |
| bit xor XOR | ^ | da esquerda para a direita |
| bit ou OR | | | da esquerda para a direita |
| lógico e AND | && | da esquerda para a direita |
| lógico ou OR | || | da esquerda para a direita |
| condicional | ?: | da direita para a esquerda |
| atribuição | = += -= *= /= %=>>= <<= &= ^= |= | da direita para a esquerda |
| vírgula | , | da esquerda para a direita |
Veja o exemplo a seguir para entender a prioridade dos operadores em C:
#include <stdio.h>
main()
{
int a = 20;
int b = 10;
int c = 15;
int d = 5;
int e;
e = (a + b) * c / d; // ( 30 * 15 ) / 5
printf("(a + b) * c / d valor é %d\n", e);
e = ((a + b) * c) / d; // (30 * 15 ) / 5
printf("((a + b) * c) / d valor é %d\n
e = (a + b) * (c / d); // (30) * (15/5)
printf("(a + b) * (c / d) valor é %d\n", e);
e = a + (b * c) / d; // 20 + (150/5)
printf("a + (b * c) / d valor é %d\n
return 0;
}Quando o código acima for compilado e executado, ele produzirá o seguinte resultado:
(a + b) * c / d valor é 90 ((a + b) * c) / d valor é 90 (a + b) * (c / d) valor é 90 a + (b * c) / d valor é 50