auto lam = [](int a, int b, int c) { return a < b && b < c; };

struct functor {
  int a;
  int b;
  bool operator()(int n) const { return a < n && n < b; }
};

En la versión uno, nosotros

std::vector<std::function<bool (int)>> lamvals;
// get parameters and for each
lamvals.emplace_back(std::bind(lam, a, std::placeholders::_1, b));

La alternativa es

std::vector<functor> lamvals;
// get parameters and for each
lamvals.emplace_back(functor{a, b});

En ambos casos tenemos una iteración simple

    return std::any_of(lamvals.cbegin(), lamvals.cend(),
            [n](const decltype(lamvals)::value_type & t){return t(n);});

Estoy viendo una diferencia de velocidad de 3: 1, con el lambda encuadernado más lento. El functor es casi tan rápido como almacenar pares enteros y codificar las pruebas. Obviamente, el hardcoding no es tan útil para el código de producción, porque habrá varias funciones en juego, no solo entre ellas. Sin embargo, puedo ir con muchos functors o muchas lambdas. Este último tiene menos líneas de código y parece más limpio, pero no creo que pueda permitirme esa diferencia de velocidad; Este código está en un ciclo crítico.

Estoy buscando sugerencias de aceleración.