Tweet

Operadores em linguagem Rust

Em programação, um operador é um símbolo define uma função que será realizada sobre os dados em uma aplicação. Os dados sobre os quais esses operadores atuam são chamados de operandos.

Consideremos a seguinte expressão:

9 + 10 = 19

Aqui, os valores 9 e 10 são os operandos, enquanto os sinais + e = são os operadores. Já o valor 19 é o resultado da operação realizada – no caso, uma operação aritmética de soma de dois números inteiros.

A linguagem Rust possui suporte a diversos tipos de operadores, e os principais operadores primários podem ser classificados como:

• Aritméticos
• Bitwise (Operadores bit-a-bit)
• Relacionais ou de Comparação
• Lógicos

Vejamos quais são esses operadores, suas funções e exemplos de uso de cada um deles.

Operadores Aritméticos

Os operadores aritméticos são empregados na realização de cálculos aritméticos simples, usando as quatro operações básicas da matemática mais a operação como o módulo.

A tabela a seguir mostra os operadores aritméticos com sua descrição, e um exemplo de uso de cada. Nos exemplos, vamos imaginar que os valores em duas variáveis a e b são 10 e 5, respectivamente.

Operador	Descrição	Exemplo
+	Retorna a soma dos operandos	a + b é 15
–	Retorna a diferença dos valores	a – b é 5
*	Retorna o produto dos valores	a * b é 50
/	Realiza a divisão e retorna o quociente	a / b é 2
%	Realiza a divisão e retorna o restante	a % b é 0

Nota: Os operadores de incremento e decremento ++ e -- não são suportados em Rust. Vejamos agora exemplos de código que usam esses operadores.

Exemplo de uso de operadores aritméticos

fn main() {
  let a = 10;
  let b = 5;
  println!("Soma: {}", a + b); // Soma
  println!("Subtração: {}", a - b); // Subtração
  println!("Multiplicação: {}", a * b); // Multiplicação
  println!("Divisão: {}", a / b); // Divisão
  println!("Módulo: {}", a % b); // Resto da divisão inteira
}

Saída:

Soma: 15
Subtração: 5
Multiplicação: 50
Divisão: 2
Módulo: 0

Operadores Relacionais

Os operadores relacionais testam ou definem o tipo de relação entre duas entidades. São usados para comparar dois ou mais valores, sendo também conhecidos como operadores de comparação, e retornam sempre um valor booleano (true ou false).

A tabela a seguir mostra os operadores relacionais com sua descrição, e um exemplo de uso de cada. Vamos assumir os valores de variáveis A = 10 e B = 20 nos exemplos.

Operador	Descrição	Exemplo
>	Maior que	(A > B) é False
<	Menor que	(A < B) é True
>=	Maior ou igual a	(A >= B) é False
<=	Menor ou igual a	(A <= B) é True
==	Igual a	(A == B) é False
!=	Diferente de	(A != B) é True

Vejamos agora exemplos de código que usam os operadores de comparação / relacionais.

Exemplo de uso de operadores relacionais

fn main() {
  let a = 10;
  let b = 20;
  println!("a vale {a} e b vale {b}");
  println!("{a} é maior que {b}? {}", a > b);
  println!("{a} é menor que {b} ? {}", a < b);
  println!("{a} é maior ou igual a {b} ? {}", a >= b);
  println!("{a} é menor ou igual a {b} ? {}", a <= b);
  println!("{a} é igual a {b} ? {}", a == b);
  println!("{a} é diferente de {b} ? {}", a != b);
}

Saída:

a vale 10 e b vale 20
a é maior que b? false
a é menor que b? true
a é maior ou igual a b? false
a é menor ou igual a b? true
a é igual a ? false
a é diferente de b? true

Operadores Lógicos

Os operadores lógicos são usados para combinar duas ou mais condições e retornam um valor booleano, que é True (verdadeiro) ou False (falso). Vamos assumir novamente os valores A = 10 e B = 20.

Operador	Descrição	Exemplo
&&	Retorna true se todas as condições forem verdadeiras; se uma das condições for falsa, retorna false.	(A > 10 && B > 10) é False
||	Retorna true se pelo menos uma das condições for true;somente retorna false se todas as condições forem falsas.	(A > 10 || B > 10) é True
!	Operador unário inversor (age sobre um único operando). Retorna o inverso do valor lógico do operando (que pode ser uma expressão): se o valor for True, retorna False, e se for False, retorna True.	!(A > 10) é True

Exemplo de uso de operadores lógicos

fn main() {
  let a = 10;
  let b = 20;
  println!("a vale {a} e b vale {b}");
  println!("AND lógico: {}", a > 5 && b > 15); // True se ambas as condições forem verdadeiras
  println!("OR lógico: {}", a > 15 || b > 15); // True se ao menos uma condição for verdadeira
  println!("NOT lógico: {}", !(a > 15)); // Inverte o resultado
}

Saída:

a vale 10 e b vale 20
AND lógico: true
OR lógico: true
NOT lógico: true

Operadores Bitwise e de Deslocamento de Bits

Os operadores de bit-a-bit ou bitwise realizam operações diretamente sobre os bits de dois ou mais números. Em vez de trabalhar com valores booleanos (verdadeiro / falso), eles trabalham a nível de bit, o que significa que cada bit de um número é comparado ao bit correspondente do outro número.

Esses operadores são muito usados em programação para manipular valores binários, criar máscaras de bits, realizar otimizações em algoritmos e resolver problemas relacionados à lógica binária.

Já os os operadores de deslocamento de bits (<< e >>), ou operadores bitwise shift são usados para mover os bits de um número inteiro para a esquerda ou para a direita. São úteis em muitas situações, como manipulação de dados de baixo nível, otimizações em cálculos e implementação de algoritmos matemáticos.

Sejam as variáveis A = 2 e B = 3:

Operador	Descrição	Exemplo
&	AND bit a bit. Somente retorna 1 se todas os bits de entrada dos operandos forem iguais a 1.	A & B = 2
|	OR bit a bit. Somente retorna 0 se todos os bits de operandos forem iguais a 0.	(A | B) é 3
^	XOR bit a bit. Retorna 0 se os bits de entrada forem iguais, e retorna 1 se forem diferentes.	(A ^ B) é 1
~	NOT bit a bit. Inverte a condição de entrada: 0 se torna 1, e 1 se torna 0. Trata-se de um operador unário inversor.	(~B) é -4
<<	Deslocamento à esquerda. Move os bits de um número para a esquerda por um número especificado de posições. A cada posição que os bits são movidos, o valor do número é multiplicado por 2.	(A << 1) é 4
>>	Deslocamento à direita. Move os bits de um número para a direita por um número especificado de posições. A cada posição que os bits são movidos, o valor do número é dividido por 2, desprezando o resto.	(A >> 1) é 1

O operador de deslocamento à esquerda (<<), na prática, multiplica o número por 2 a cada deslocamento. Já o operador de deslocamento à direita (>>) divide o número por 2 a cada deslocamento, descartando a parte fracionária.

Exemplo de uso de operadores bit a bit

fn main() {
  let a: u8 = 2; // 0000_0010 em binário
  let b: u8 = 3; // 0000_0011 em binário
  println!("a vale {a} e b vale {b}");
  println!("AND bitwise: {}", a & b); // 0000_0010
  println!("OR bitwise: {}", a | b); // 0000_0011
  println!("XOR bitwise: {}", a ^ b); // 0000_0001
  println!("NOT bitwise: {}", !b); // Inversão de todos os bits
  println!("Shift à esquerda: {}", a << 1); // Desloca os bits para a esquerda
  println!("Shift à direita: {}", a >> 1); // Desloca os bits para a direita
}

Saída:

a vale 2 e b vale 3
AND bitwise: 2
OR bitwise: 3
XOR bitwise: 1
NOT bitwise: 252
Shift à esquerda: 4
Shift à direita: 1

Conclusão

Neste artigo vimos quais são os principais operadores utilizados em linguagem Rust, sua importância e utilidade, e alguns exemplos de uso de cada um deles. Nos próximos tutoriais vamos usar esses operadores para criar programas mais complexos, usando outras estruturas de programação como laços de repetição, decisão condicional e arrays, entre outras.