Uma das operações mais utilizadas em programação é a operação de atribuição =. Essa operação é responsável por armazenar determinado valor em uma variável. Em linguagem C, o uso do operador de atribuição segue a sintaxe nome_da_variável = expressão. Abaixo, um programa demonstrando o uso do operador de atribuição:
1 #include <stdio.h>
2
3 int main(void) {
4
5 int x = 10;
6 printf("x = %d\n", x);
7
8 return 0;
9
10 }
Nós já executamos esse programa anteriormente e sabemos que o valor inteiro 10 está sendo atribuído à variável x, portanto, já estamos naturalizados com essa expressão. Sabemos também que podemos atribuir um valor à uma variável após sua definição, não necessariamente a inicializando, eis um exemplo:
1 #include <stdio.h>
2
3 int main(void) {
4
5 int x;
6 x = 10;
7 printf("x = %d\n", x);
8
9 return 0;
10
11 }
x é inicializado com um lixo de memória, mas na linha seguinte atribuímos um valor à variável.
É importante ter sempre em mente que o operador de atribuição calcula a expressão à direita do operador = e atribui esse valor à variável à esquerda do operador, nunca o contrário. Desse modo, podemos fazer as seguintes atribuições:
1 #include <stdio.h>
2
3 int main(void) {
4
5 int x, y, z;
6 x = y = z = 20;
7 printf("x = %d\ny = %d\nz = %d\n", x, y, z);
8
9 return 0;
10
11 }
No código acima, o valor 20 é copiado para a variável z. Lembre-se: o valor da direita é sempre armazenado na variável especificada à sua esquerda. Em seguida, o valor de z é copiado para a variável y e, na sequência, o valor de y é copiado para x.
Ao executar o programa, a saída que obtemos é a seguinte:
Note que os operadores aritméticos são sempre usados em conjunto com o operador de atribuição. Afinal de contas, alguém precisa receber o resultado da expressão aritmética. Abaixo, um programa demonstrando o uso de cada um dos operadores aritméticos:
1 #include <stdio.h>
2
3 int main(void) {
4
5 int x = 10, y = 20, z, i, j, k, n;
6
7 z = x + y; // 30
8 i = z - x; // 20
9 j = i * 2; // 40
10 k = j / i; // 2
11 n = i % 2; // 0
12
13 printf("\nx = %d", x);
14 printf("\ny = %d", y);
15 printf("\nz = %d", z);
16 printf("\ni = %d", i);
17 printf("\nj = %d", j);
18 printf("\nk = %d", k);
19 printf("\nn = %d", n);
20 printf("\n%d + %d - 5 = %d\n", x, z, x + z - 5);
21
22 return 0;
23
24 }
Note, no código acima, que podemos devolver o resultado de uma expressão aritmética para outra variável (linha 7 a 11) ou para outro comando ou função que espere receber um valor do mesmo tipo de resultado da operação, no caso, a função printf() (linha 20).
Ao executar o programa, a saída que obtemos é a seguinte:
z = x + * y + 10;
Nela, o valor de x será multiplicado pelo valor de y, e o resultado dessa mutliplicação será somado ao valor 10 para só então ser atribuído à variável z. Se quiseremos a operação de adição antes da de multiplicação, basta colocá-la entre parênteses. Assim, na expressão
z = x + * (y + 10);
o valor de y será somado ao valor 10, e o resultado dessa adição será multiplicado pelo valor de x para só então ser atribuído à variável x.
Obs.: O operador de resto da divisão só é válido para valores inteiros (tipo int e char).Os operadores relacionais são aqueles que operam sobre dois valores (valores, variáveis, constantes ou chamadas de funções) e/ou expressões e verificam a magnitude (qual é maior ou menor) e/ou igualdade entre eles. Basicamente, os operadores relacionais são operadores de comparação de valores. A linguagem C possui um total de seis operadores relacionais, como mostra a tabela a seguir:
Como resultado, esse tipo de operador retorna:
Um erro bastante comum quando se está programando em linguagem C é confundir o operador de atribuição = com o operador de atribuição ==. O operador de atribuição é definido por UM símbolo de igual (=), enquanto o operador de comparação é definido por DOIS símbolos de igual (==). Abaixo, um programa demonstrando o uso de cada um dos operadores relacionais:
1 #include <stdio.h>
2
3 int main(void) {
4
5 int x = 10, y = 5;
6
7 printf("Resultado: %d\n", x > 10); // falso (0)
8 printf("Resultado: %d\n", x >= 10); // verdadeiro (1)
9 printf("Resultado: %d\n", y < x); // verdadeiro (1)
10 printf("Resultado: %d\n", y <= 2); // falso (0)
11 printf("Resultado: %d\n", x == y); // falso (0)
12 printf("Resultado: %d\n", y != 10); // verdadeiro (1)
13
14 return 0;
15
16 }
Ao executar o programa, a saída que obtemos é a seguinte:
Certas situações não podem ser modeladas apenas utilizando os operadores aritméticos e/ou relacionais. Um exemplo bastante simples disso é saber se determinada variável x está dentro de uma faixa de valores. Por exemplo, a expressão aritmética
0 < x < 10
indica que o valor de x deve ser maior do que 0 (zero) e também menor que 10. Para modelar esse tipo de situação, a linguagem C possui um conjunto de três operadores lógicos, como mostra a tabela a seguir:
Esse operadores permitem representar situações lógicas unindo duas ou mais expressões relacionais simples em uma composta:
Os operadores lógicos atuam sobre valores lógicos e retornam um valor lógico:
Abaixo, um programa demonstrando o uso de cada um dos operadores lógicos:
1 #include <stdio.h>
2
3 int main(void) {
4
5 int r, x = 5, y = 3;
6
7 r = (x > 2) && (y < x); // verdadeiro (0)
8 printf("\nResultado: %d\n", r);
9
10 r = (x % 2 == 0) && (y > 0); // falso (0)
11 printf("Resultado: %d\n", r);
12
13 r = (x > 2) || (y > x); // verdadeiro (0)
14 printf("Resultado: %d\n", r);
15
16 r = (x % 2 == 0) || (y < 0); // falso (0)
17 printf("Resultado: %d\n", r);
18
19 r = !(x > 2); // falso (0)
20 printf("Resultado: %d\n", r);
21
22 r = !(x > 7) && (x > y); // verdadeiro (1)
23 printf("Resultado: %d\n", r);
24
25 return 0;
26
27 }
Ao executar o programa, a saída que obtemos é a seguinte:
A tabela a seguir apresenta a tabela-verdade, em que os termos a e b representam o resultado de duas expressões relacionais:
A linguagem C também possui operadores de incremento (++) e decremento (--). Esses operadores podem ser utilizados sempre que for necessário somar uma unidade (incremento) ou subtrair uma unidade (decremento) a determinado valor, como mostra a seguinte tabela:
Tanto o operador de incremento (++) quanto o de decremento (--) possuem embutida uma operação de atribuição. Note, no entanto, que esse operador pode ser usado antes ou depois do nome da variável, com uma diferença significativa:
Essa diferença na sintaxe não tem importância se o operador for utilizado sozinho, como demonstram os programas abaixos:
|
1 #include <stdio.h> |
1 #include <stdio.h> |
Ao executar os programas, as saídas que obtemos são as seguintes:
Porém, se esse operador for utilizado dentro de uma expressão aritmética, a diferença entre os dois operadores será evidente. Comecemos pelo operador de pré-incremento:
1 #include <stdio.h>
2
3 int main(void) {
4
5 int y, x = 10;
6
7 // incrementa, depois atribui
8 y = ++x;
9
10 printf("x = %d\n", x);
11 printf("y = %d\n", y);
12
13 return 0;
14
15 }
Ao executar o programa, a saída que obtemos é a seguinte:
Como se pode ver, o operador de pré-incremento (++x) é a primeira coisa a ser realizada dentro da expressão. Somente depois de incrementado o valor de x é que ele é atribuído à variável y. Nota-se, nesse caso, que a expressão
y = ++x;
é equivalente a
x = x + 1;
y = x;
Abaixo, o mesmo programa, agora utilizando o operador de pós-incremento:
1 #include <stdio.h>
2
3 int main(void) {
4
5 int y, x = 10;
6
7 // atribui, depois incrementa
8 y = x++;
9
10 printf("x = %d\n", x);
11 printf("y = %d\n", y);
12
13 return 0;
14
15 }
Ao executar o programa, a saída que obtemos é a seguinte:
Nesse segundo exemplo, o operador de pós-incremento (x++) é a última coisa a ser realizada dentro da expressão. Primeiro atribui-se o valor de x à variável y, para somente depois incrementar a variável x. Nota-se, nesse caso, que a expressão
y = x++;
é equivalente a
y = x;
x = x + 1;
Como podemos ver, a linguagem C contém muitos operadores. Consequentemente, o uso de múltiplos operadores em uma única expressão pode tornar confusa a sua interpretação. Por esse motivo, a linguagem C possui uma série de regras de precedência de operadores. Isso permite que o compilador possa decidir corretamente qual a ordem em que os operadores deverão ser executados em uma expressão contendo vários. As regras de precedência seguem basicamente as regras da matemática, pelas quais a multiplicação e a divisão são executadas antes da soma e da subtração. Além disso, podem-se utilizar parênteses para forçar o compilador a executar uma parte da expressão antes das demais.
A seguir, uma lista ordenada que mostra as regras de precedência dos principais operadores presentes na linguagem C. Quanto menor o número, maior o nível de precedência (prioridade) dos operadores em questão. Na primeira posição da lista são apresentados os opeadores executados em primeiro lugar, enquanto a última posição da lista mostra os operadores executados por último em uma expressão: