Para calcular o resto de uma divisão em C++, basta usar o operador % – também conhecido como operador módulo. O operador % retorna o resto da divisão entre dois inteiros. Veja no exemplo abaixo como usar o operador módulo em C++.
Exemplo 1 – operador % em C++ para obter o resto de uma divisão
#include <iostream>
int main() {
int x = 10;
int y = 3;
std::cout << "O resto da divisao de x por y eh: " << x % y << std::endl;
return 0;
}
O operador % só funciona se os operandos forem valores de tipo inteiro.
Usar o operador % para percorrer um array
Há também um outro uso do operador % que deriva do primeiro e é bastante útil para se percorrer arrays criados à moda antiga usando new (veja meu artigo sobre porquê não criar arrays dessa maneira – ao invés deles use vector) ou um array no estilo C. Para explicar esse uso do operador %, irei usar um exemplo.
Suponha que você tenha um array de inteiros com 5 elementos, e que você tenha uma variável usada para acessar um elemento desse vetor. A pegadinha aqui é que esta variável pode ter, em princípio, qualquer valor de 0 até infinito (obviamente ela não será infinita, mas espero que você tenha entendido a idéia). Como você pode fazer para garantir que no seu programa apenas os índices de 0 a 4 (que são os índices do seu array) serão acessados, se a variável pode ter qualquer valor? Veja esse exemplo de problema no código abaixo.
#include <iostream>
int main() {
int a[5] {1, 2, 3, 4, 5};
int idx {0};
std::cout << "Digite o indice do valor que voce deseja acessar no array: ";
std::cin >> idx;
std::cout << "O valor pedido eh " << a[idx] << std::endl;
return 0;
}
No exemplo acima basta que o usuário digite um número maior que 4 para que o programa acesse uma região de memória que não pertence mais ao array, e seu comportamento será imprevisível. Como você poderia garantir, então, que o índice acessado no array estará sempre entre 0 e 4, não importando quão grande seja o valor fornecido pelo usuário? Aí está o truque do operador %.
O uso do operador % sobre o valor de idx, fornecendo-lhe como denominador o número 5 (que é o tamanho do array), garantirá que sempre que um número maior que 4 seja fornecido, o valor será “resetado” para 0. Deixe me explicar de outra forma. Na verdade, o uso do operador % nesse caso garante os múltiplos inteiros de 5 sejam “removidos” do valor original fornecido pelo usuário, sobrando só uma parte que é menor do que 5.
Considere que o usuário digitou o valor 83. O trabalho do operador % é o de “remover” 80 do valor 83, restando-lhe apenas o valor 3. Assim, o número do índice 3 do array será acessado. Muito doido, não? Veja abaixo como isso funciona na prática.
#include <iostream>
int main() {
static constexpr int arraySize {5};
int a[arraySize] {1, 2, 3, 4, 5};
int idx {0};
std::cout << "Digite o indice do valor que voce deseja acessar no array: ";
std::cin >> idx;
std::cout << "O valor pedido eh " << a[idx % arraySize] << std::endl;
return 0;
}
Conclusão
Vimos neste artigo como o operador % em C++ pode ser usado para obter-se o resto de uma divisão, e como esta capacidade nos permite criar um “truque” para garantir que índices fora dos limites de um array nunca serão acessados no nosso programa – e tudo isso em menos de 10 minutos!
Gostou do artigo? Então inscreva-se na nossa newsletter para não perder nenhum dos nossos artigos 🙂
Sou apaixonado por tecnologia, literatura e também filosofia. O cultivo dessas paixões ao longo da minha trajetória me inspiraram a compartilhar aquilo que aprendo com os outros da maneira mais clara que eu possa. Sou formado em Engenharia Elétrica no Brasil, e também sou engenheiro formado na França. Trabalho atualmente como programador C++ em uma multinacional francesa, uma das maiores empresas de TI do mundo.
