HOWTO · C++

Utilizar o Operador Modulo em C++

Este artigo introduz como utilizar o operador do módulo em C++

Nesta página

O operador % de C++ retorna o resto da divisão inteira. Por exemplo, 10 % 3 é 1. Ele funciona com tipos integrais, incluindo inteiros com sinal, mas não aceita operandos de ponto flutuante. O divisor deve ser diferente de zero. Use o resultado para verificar paridade, calcular posições cíclicas e obter índices de buckets dentro de um intervalo, levando em conta os valores com sinal quando necessário.

O que o operador % de C++ retorna

Para inteiros a e b, a % b é o resto que sobra após a / b. Em C++, a divisão inteira trunca em direção a zero; por isso, 10 / 3 é 3 e 10 % 3 é 1. Ambos os operandos devem ter tipos integrais; usar % com um operando não integral torna a expressão malformada. O divisor também deve ser diferente de zero, pois um divisor zero causa comportamento indefinido.

Este pequeno programa mostra um cálculo positivo típico:

#include <iostream>

int main() {
    const int dividend = 17;
    const int divisor = 5;
    std::cout << dividend % divisor << '\n';
}
2

O operador % não é definido para valores de ponto flutuante. Quando precisar do resto de uma operação com ponto flutuante, use std::fmod de <cmath>.

Como % funciona com inteiros com sinal

Para operandos com sinal, a divisão inteira trunca em direção a zero, e um resto diferente de zero tem o mesmo sinal do dividendo. Assim, -10 % 3 é -1, enquanto 10 % -3 é 1; nos dois casos, o quociente multiplicado pelo divisor, mais o resto, é igual ao dividendo. Esse comportamento é especificado por C++ e não fica a critério do compilador.

Como um resto negativo continua negativo, % sozinho nem sempre produz um índice não negativo. Se precisar de um resultado normalizado, use um módulo positivo m, armazene value % m em uma variável de resto e some m somente quando esse resto for negativo. Como o resto é maior que -m, isso produz um resultado no intervalo [0, m) sem uma soma intermediária que possa causar overflow. O quociente também precisa ser representável: % causa comportamento indefinido quando o quociente correspondente da divisão inteira não pode ser representado, como ocorre com o menor valor de um tipo com sinal % -1. A identidade do resto acima não se aplica a esse caso de comportamento indefinido.

Verifique a paridade e percorra valores ciclicamente com %

Um inteiro é par quando value % 2 == 0; caso contrário, é ímpar. Isso também funciona para inteiros negativos, pois um múltiplo exato de dois tem resto zero.

Para indexar ciclicamente, use um tamanho positivo para a coleção e uma posição não negativa:

#include <iostream>

int main() {
    const int values[] = {10, 20, 30};
    const int count = static_cast<int>(sizeof(values) / sizeof(values[0]));

    for (int position = 0; position < 5; ++position) {
        const int index = position % count;
        std::cout << values[index] << '\n';
    }
}
10
20
30
10
20

O array contém três elementos, então cada índice fica no intervalo de 0 a 2; a sequência de posições se repete à medida que o loop avança. Esse padrão pressupõe que a coleção tenha pelo menos um elemento. Se as posições puderem ser negativas, normalize o resto antes de usá-lo como índice.

Use restos em hashing e em intervalos de números aleatórios

Uma tabela hash pode usar um resto para mapear uma chave não negativa para uma tabela com tableSize buckets: key % tableSize. Isso exige tableSize > 0. Se as chaves puderem ser negativas, normalize o resultado como descrito acima antes de convertê-lo em índice. Tabelas hash reais também precisam de uma função hash e de uma estratégia para colisões; o resto apenas seleciona um intervalo de buckets.

Para gerar inteiros aleatórios, não presuma que std::rand() % bound produz uma distribuição uniforme: se a quantidade de valores possíveis do gerador não for múltipla de bound, alguns resultados ocorrerão com maior frequência. Quando quiser um intervalo inteiro inclusivo, prefira std::uniform_int_distribution com um motor aleatório:

#include <iostream>
#include <random>

int main() {
    std::mt19937 engine(12345);
    std::uniform_int_distribution<int> range(1, 6);
    std::cout << range(engine) << '\n';
}
6

Os parâmetros da distribuição definem os limites inferior e superior inclusivos. Com esta semente, este motor e a implementação da biblioteca padrão de std::uniform_int_distribution testada, o exemplo imprime 6. C++ não exige que a distribuição mapeie as saídas do motor da mesma forma em todas as implementações da biblioteca padrão; portanto, a saída exata e a sequência não são portáveis. Elas só se repetem quando tanto o motor quanto a implementação da distribuição são os mesmos. Quando precisar de sequências diferentes, escolha uma fonte de sementes adequada à sua aplicação.

Use std::modulus como objeto de função

std::modulus, em <functional>, é um objeto de função que aplica % a dois valores. Ele é útil quando um algoritmo espera um objeto chamável em vez de uma expressão com operador:

#include <functional>
#include <iostream>

int main() {
    const std::modulus<int> remainder;
    std::cout << remainder(17, 5) << '\n';
}
2

Seus operandos seguem as mesmas regras de %: devem ser integrais e o divisor deve ser diferente de zero. Para expressões comuns, a % b costuma ser a forma mais clara.