HOWTO · C++

Usar el Operador de Módulos en C++

Este artículo introduce cómo usar el operador de módulo en C++

En esta página

El operador % de C++ devuelve el resto de una división entera. Por ejemplo, 10 % 3 es 1. Funciona con tipos enteros, incluidos los enteros con signo; no acepta operandos de punto flotante. El divisor debe ser distinto de cero. El resultado sirve para comprobar la paridad, calcular posiciones cíclicas y obtener índices de cubetas acotados, teniendo en cuenta los valores con signo cuando sea necesario.

Qué devuelve el operador % de C++

Para los enteros a y b, a % b es el resto que queda después de a / b. C++ trunca la división entera hacia cero, por lo que 10 / 3 es 3 y 10 % 3 es 1. Ambos operandos deben tener tipos enteros; si se usa % con un operando no entero, la expresión está mal formada. El divisor también debe ser distinto de cero, porque un divisor cero provoca comportamiento indefinido.

Este pequeño programa muestra un cálculo positivo típico:

#include <iostream>

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

El operador % no está definido para valores de punto flotante. Si necesitas obtener el resto de una operación con valores de punto flotante, usa std::fmod de <cmath>.

Cómo funciona % con enteros con signo

Con operandos con signo, la división entera se trunca hacia cero y, si el resto no es cero, tiene el mismo signo que el dividendo. Así, -10 % 3 es -1, mientras que 10 % -3 es 1; en ambos casos, el cociente multiplicado por el divisor más el resto es igual al dividendo. Este comportamiento está especificado por C++, no depende de la elección del compilador.

Como un resto negativo sigue siendo negativo, % por sí solo no siempre produce un índice no negativo. Si necesitas un resultado normalizado, usa un módulo positivo m, guarda value % m en una variable para el resto y suma m solo si ese resto es negativo. Como el resto es mayor que -m, así se obtiene un resultado en [0, m) sin una suma intermedia que pueda desbordarse. Además, el cociente debe poder representarse: % provoca comportamiento indefinido cuando el cociente de la división entera correspondiente no se puede representar, como ocurre con el valor mínimo de un tipo con signo % -1. La identidad del resto indicada arriba no se aplica a ese caso de comportamiento indefinido.

Comprueba la paridad y recorre valores en ciclo con %

Un entero es par cuando value % 2 == 0; de lo contrario, es impar. Esto también funciona con enteros negativos, porque un múltiplo exacto de dos tiene resto cero.

Para indexar de forma cíclica, usa un tamaño de colección positivo y una posición no 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

El array contiene tres elementos, por lo que cada índice está en el intervalo de 0 a 2; las posiciones se repiten a medida que avanza el bucle. Este patrón presupone que la colección tiene al menos un elemento. Si las posiciones pueden ser negativas, normaliza el resto antes de usarlo como índice.

Usa restos en hashing y en rangos de números aleatorios

Una tabla hash puede usar un resto para asignar una clave no negativa a una tabla con tableSize cubetas: key % tableSize. Esto requiere que tableSize > 0. Si las claves pueden ser negativas, normaliza el resultado como se describió antes de convertirlo en un índice. Las tablas hash reales también necesitan una función hash y una estrategia para resolver colisiones; el resto solo selecciona una cubeta dentro del rango.

Para generar enteros aleatorios, no supongas que std::rand() % bound produce una distribución uniforme: si la cantidad de valores posibles del generador no es múltiplo de bound, algunos resultados aparecen con más frecuencia. Si necesitas un intervalo entero inclusivo, es preferible usar std::uniform_int_distribution con un motor aleatorio:

#include <iostream>
#include <random>

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

Los parámetros de la distribución definen los límites inferior y superior incluidos. Con esta semilla, este motor y la implementación de la biblioteca estándar probada para std::uniform_int_distribution, el ejemplo imprime 6. C++ no exige que la distribución asigne los resultados del motor de la misma manera en todas las implementaciones de la biblioteca estándar, por lo que la salida y la secuencia exactas no son portables; solo son repetibles si coinciden tanto el motor como la implementación de la distribución. Si necesitas secuencias distintas, elige una fuente de semillas adecuada para tu aplicación.

Usa std::modulus como objeto de función

std::modulus de <functional> es un objeto de función que aplica % a dos valores. Es útil cuando un algoritmo espera un objeto invocable en lugar de una expresión con un operador:

#include <functional>
#include <iostream>

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

Sus operandos siguen las mismas reglas de tipos enteros y divisor distinto de cero que %. En expresiones comunes, a % b suele ser la forma más clara.