La forma más rápida de determinar si un entero está entre dos enteros (inclusive) con conjuntos de valores conocidos

Depende de cuántas veces desee realizar la prueba sobre los mismos datos.

Si está realizando la prueba una sola vez, probablemente no haya una forma significativa de acelerar el algoritmo.

Si está haciendo esto para un conjunto muy finito de valores, entonces podría crear una tabla de búsqueda. Realizar la indexación puede ser más costoso, pero si puede caber toda la tabla en caché, entonces puede eliminar todas las ramificaciones del código, lo que debería acelerar las cosas hasta.

Para sus datos la tabla de búsqueda sería 128^3 = 2,097,152. Si puede controlar una de las tres variables para considerar todas las instancias donde start = N a la vez, entonces el tamaño del conjunto de trabajo se reduce a 128^2 = 16432 bytes, lo que debería encajar bien en la mayoría de las cachés modernas.

Todavía tendría que comparar el código real para ver si una tabla de búsqueda sin ramas es lo suficientemente rápida que las comparaciones obvias.

Es raro poder hacer optimizaciones significativas al código a una escala tan pequeña. Las grandes ganancias de rendimiento provienen de observar y modificar el código desde un nivel superior. Puede ser capaz de eliminar la necesidad de la prueba de rango por completo, o solo hacer O(n) de ellos en lugar de O(n^2). Es posible que pueda reordenar las pruebas para que siempre se implique un lado de la desigualdad. Incluso si el algoritmo es ideal, las ganancias son más probables cuando vea cómo este código hace la prueba de rango 10 millones de veces y encuentras una manera de agruparlos y usar SSE para hacer muchas pruebas en paralelo.

Esta respuesta es para informar sobre una prueba realizada con la respuesta aceptada. Realicé una prueba de rango cerrado en un vector grande de entero aleatorio ordenado y para mi sorpresa el método básico de ( low

int num = rand();  // num to compare in consecutive ranges.
chrono::time_point<chrono::system_clock> start, end;
auto start = chrono::system_clock::now();

int inBetween1{ 0 };
for (int i = 1; i < MaxNum; ++i)
{
    if (randVec[i - 1] <= num && num <= randVec[i])
        ++inBetween1;
}
auto end = chrono::system_clock::now();
chrono::duration<double> elapsed_s1 = end - start;

Comparado con lo siguiente que es la respuesta aceptada arriba:

int inBetween2{ 0 };
for (int i = 1; i < MaxNum; ++i)
{
    if (static_cast<unsigned>(num - randVec[i - 1]) <= (randVec[i] - randVec[i - 1]))
        ++inBetween2;
}

Presta atención a que randVec es un vector ordenado. Para cualquier tamaño de MaxNum el primer método supera al segundo en mi máquina!

¿No es posible simplemente realizar una operación bitwise en el entero?

Puesto que tiene que estar entre 0 y 128, si el bit 8 está establecido (2^7) es 128 o más. El caso edge será un dolor, sin embargo, ya que desea una comparación inclusiva.