Concepts prefiere una sobrecarga más restringida sobre una sobrecarga menos restringida, por lo que no necesita excluir el dominio de una implementación restringida del dominio de una implementación sin restricciones como lo haría con SFINAE. Su implementación básica podría escribirse como:

template <typename It>
std::size_t distance(It it, It end) {
    std::size_t size{};
    while (it != end) {
        ++it;
        ++size;
    }
    return size;
}

template <typename It>
requires is_random_access_v<It>
std::size_t distance(It begin, It end) {
    return end - begin;
}

No es necesario excluir iteradores de acceso aleatorio (el dominio de la sobrecarga restringida) del dominio de la sobrecarga no restringida.

Si todos los iteradores segmentados son al azar o todos los iteradores aleatorios están segmentados, luego de nuevo los conceptos preferirán la sobrecarga más restringida y todo está bien. Solo tienes que añadir la nueva sobrecarga restringida:

template <typename It>
requires SegmentedIterator<It>
std::size_t distance(It begin, It end) {
    // ...
}

Si tiene sobrecargas restringidas con rangos superpuestos, pero ninguna subsume las restricciones de la otra, la resolución de sobrecarga es ambigua al igual que con SFINAE. Sin embargo, romper la ambigüedad es un poco más simple, ya que solo es necesario agregar una nueva sobrecarga para especificar el comportamiento en la región de solapamiento:

template <typename It>
requires SegmentedIterator<It> && is_random_access_v<It>
std::size_t distance(It begin, It end) {
    // ...
}

SFINAE requeriría excluir adicionalmente la superposición del dominio de las otras sobrecargas, pero los Conceptos preferirán esta sobrecarga más restringida sin requerir cambios en las sobrecargas para SegmentedIterator y is_random_access_v.

Concepts permite al usuario extender fácilmente su implementación genérica con sobrecargas ortogonales. Las sobrecargas no ortogonales requieren más esfuerzo para especificar el comportamiento en la "superposición", pero no requieren cambios en el código original como SFINAE gustar.

Tenga en cuenta que puede "emular" conceptos en C++11 usando el truco de Walter Brown void_t (ver void_t "can implement concepts"?).

Entonces puede proporcionar una implementación base como una plantilla de clase

template <typename It, class=void>
struct dist_impl {
auto operator()(It it, It end) -> std::size_t {
    std::size_t size{};
    while (it != end) {
        ++it;
        ++size;
    }
    cout << "base distance\n";
    return size;
}
};

Y hacer especialización parcial con void_t para que el compilador elija la coincidencia más especializada

template <typename It>
struct dist_impl<It, void_t<typename std::enable_if<is_random_access<It>::value>::type>> {
auto operator()(It begin, It end) -> std::size_t {
    cout << "random distance\n";
    return end - begin;
}
};

Se aplican las mismas consideraciones de "ortogonalidad".

Aquí hay un ejemplo completo: http://coliru.stacked-crooked.com/a/e4fd8d6860119d42

Sobrecarga

Primero, echemos un vistazo al manejo de la función distance. Usando la biblioteca Tick, puede implementar rasgos de concepto para iteradores traversals en C++ de la siguiente manera:

TICK_TRAIT(is_incrementable)
{
    template<class T>
    auto requires_(T&& x) -> tick::valid<
        decltype(x++),
        decltype(++x)
    >;
};

TICK_TRAIT(is_decrementable, is_incrementable<_>)
{
    template<class T>
    auto requires_(T&& x) -> tick::valid<
        decltype(x--),
        decltype(--x)
    >;
};

TICK_TRAIT(is_advanceable)
{
    template<class T, class Number>
    auto requires_(T&& x, Number n) -> tick::valid<
        decltype(x += n)
    >;
};

Ahora, si escribes las dos sobrecargas podría ser ambiguo. Así que hay un par de maneras de resolver la ambigüedad. En primer lugar, se puede utilizar el envío de etiquetas:

template <typename It>
auto distance(It it, It end, tick::tag<is_incrementable>) -> std::ptrdiff_t 
{
    std::ptrdiff_t size{};
    while (it != end) {
        ++it;
        ++size;
    }
    return size;
}

template <typename It>
auto distance(It begin, It end, tick::tag<is_advanceable>())
{
    return end - begin;
}

template<typename It, TICK_REQUIRES(is_incrementable<It>())>
auto distance(It begin, It end)
{
    return distance(begin, end, tick::most_refined<is_advanceable<It>());
}

Otra forma es usar la sobrecarga condicional proporcionada por la biblioteca Fit. Esto permite su orden de las funciones por importancia con el fin de evitar la ambigüedad. Puede utilizar objetos de función o lambdas. Aquí está cómo hacerlo usando lambdas genérico:

FIT_STATIC_FUNCTION(distance) = fit::conditional(
    [](auto begin, auto end, TICK_PARAM_REQUIRES(
        tick::trait<is_incrementable>(begin) and 
        tick::trait<is_incrementable>(end)))
    {
        std::ptrdiff_t size{};
        while (it != end) {
            ++it;
            ++size;
        }
        return size;
    },
    [](auto begin, auto end, TICK_PARAM_REQUIRES(
        tick::trait<is_advanceable>(begin) and 
        tick::trait<is_advanceable>(end)))
    {
        return end - begin;
    }
);

Por supuesto, esto lo convierte en un objeto de función, que tendría que envolver en una función real si desea confiar en la búsqueda ADL.

Puntos de personalización

Se pueden implementar algoritmos genéricos de tal manera que se pueda agregar una nueva idea de mejora sin cambiar las implementaciones existentes y, si es así, ¿Cómo?

Sí que pueden, pero es necesario definir los puntos de personalización.

Búsqueda ADL

Una forma es a través de la búsqueda de ADL. Las funciones std::begin y std::end funcionan de esta manera. Así que podría definir la función distance en su propio espacio de nombres privado:

namespace detail {
    template<typename It, TICK_REQUIRES(is_incrementable<It>())>
    auto distance(It begin, It end)
    {
        // Implementation of distance
    }
}

Luego puede definir otra función para que el usuario la use en otro espacio de nombres como esta:

namespace my_lib {
template<typename It, TICK_REQUIRES(is_incrementable<It>())>
auto distance(It begin, It end)
{
    using detail::distance;
    distance(begin, end);
}
}

Así que ahora puede personalizar la función distance para ciertos tipos.

Plantilla especialización

Sin embargo, ADL podría ser secuestrado inadvertidamente, y causaría que esto fallara a veces. Así que otra forma de proporcionar puntos de personalización es usar la especialización de plantillas. Así que podrías definir una plantilla que podría usarse para anular el comportamiento de distance, así:

template<class It, class=void>
struct distance_op;

Entonces la función distance podría definirse para preferir primero la distance_op:

 FIT_STATIC_FUNCTION(distance) = fit::conditional(
    [](auto begin, auto end) FIT_RETURNS
    (distance_op<decltype(begin)>::call(begin, end)),
    [](auto begin, auto end, TICK_PARAM_REQUIRES(
        tick::trait<is_incrementable>(begin) and 
        tick::trait<is_incrementable>(end)))
    {
        std::ptrdiff_t size{};
        while (it != end) {
            ++it;
            ++size;
        }
        return size;
    },
    [](auto begin, auto end, TICK_PARAM_REQUIRES(
        tick::trait<is_advanceable>(begin) and 
        tick::trait<is_advanceable>(end)))
    {
        return end - begin;
    }
);

El FIT_RETURNS limitará la lambda a cuando distance_op<decltype(begin)>::call(begin, end) sea válida. Así que si quieres personalizar distance para std::queue, podrías escribir:

template<>
struct distance_op<queue<int>::iterator>
{
    static void call(queue<int>::iterator begin, queue<int>::iterator end)
    {
        // Do queue-based distance
    }
};

Además, el segundo parámetro está allí para que pueda especializarse en función de los tipos que coinciden con ciertas restricciones, por lo que podríamos implementarlo para cada iteratar donde is_queue_iterator es verdadero, así:

template<Iterator>
struct distance_op<Iterator, TICK_CLASS_REQUIRES(is_queue_iterator<Iterator>())>
{
    static void call(queue<int>::iterator begin, queue<int>::iterator end)
    {
        // Do queue-based distance
    }
};

Mapas conceptuales

Seguimiento opcional (estoy principalmente interesado en la pregunta anterior, pero esta también podría ser interesante): Si eso no es posible, ¿se agregaría esta habilidad con conceptos?

Sí, usando mapas conceptuales usted podría extender fácilmente estas operaciones. Así que puedes crear una distancia concept como esta:

template<class Iterator>
concept Distance
{
    ptrdiff_t distance(Iterator begin, Iterator end);
}

, a Continuación, hacemos un concept_map para cuando es un Incrementable y cuando es Advanceable:

template<Incrementable Iterator>
concept_map Distance<Iterator>
{
    ptrdiff_t distance(Iterator begin, Iterator end)
    {
        std::ptrdiff_t size{};
        while (it != end) {
            ++it;
            ++size;
        }
        return size;
    }
};

template<Advanceable Iterator>
concept_map Distance<Iterator>
{
    ptrdiff_t distance(Iterator begin, Iterator end)
    {
        return end - begin;
    }
};

Y luego más tarde el usuario podría especializar el concept_map para nuevos tipos también:

template<class T>
concept_map Distance<queue<T>::iterator>
{
    ptrdiff_t distance(Iterator begin, Iterator end)
    {
        return end - begin;
    }
};

Usaría una clase de utilidad para eso, porque en ese caso es fácil darle un algoritmo predeterminado (para el caso genérico) manteniendo la posibilidad de sobrescribirlo para usos específicos. Más o menos lo que las clases del STL hacen con el Asignador:

template < class T, class Alloc = allocator<T> > class list;

De forma predeterminada, obtiene un allocator<T> pero puede proporcionarle su propia implementación.

template <class T, class Dist = dist<T> >
class dist_measurer {
public:
    static auto distance(T begin, T end) {
        return Dist.distance(begin, end);
    }
}

Luego crea el genérico dist<T>, y opcionalmente otras implementaciones específicas, todas con una sola distancia de método estático.

Cuando desea utilizar el método genérico en la clase X:

dist_measurer<X>.distance(x, y); // x and y objects of class X

Si ha implementado otro algoritmo en dist2, lo usa con:

dist_measurer<X, dist2<X> >.distance(x, y);