Как обрабатывать значение по умолчанию для шаблонного функтора

Используйте пустой функтор и используйте его как параметр шаблона по умолчанию. Вы не можете использовать что-то вроде NULL, потому что у вас нет указателя:

class X
{
    void operator()(...) {}
};

template <typename functor = X>
void foo(functor const& f = X())
{
    f(...);
}

Либо напишите перегрузку, которая принимает и ничего не делает, либо передайте бездействующий функтор в foo.

Самый простой способ - создать перегрузку без аргументов:

template<typename functor>
void foo()
{
}

Если действие по умолчанию зависит от параметра-шаблона, вам придется указать его явно, поскольку нет ничего, из чего компилятор мог бы его вывести. Если нет, то вам даже не нужно делать из него шаблон.

Я не хочу использовать перегруженные функции. Вроде бы использование самописного «ноп-класса» - лучшее решение.

struct nop
{
    void operator()(...) const volatile {}
};

template<typename functor> 
void foo(functor const& f = functor()) 
{
    f(1, 2);
}

int main()
{
    foo<nop>();
    return 0;
}

Я использую это в качестве дополнительной блокировки для случаев, когда я ожидаю, что функтор не вернет никакого значения.

struct VoidNoOp {
    void operator()() const { }
    template<class A>
    void operator()(A a) const { (void)(a); }
    template<class A, class B>
    void operator()(A a, B b) const { (void)(a); (void)(b); }
    template<class A, class B, class C>
    void operator()(A a, B b, C c) const { (void)(a); (void)(b); (void)(c); }
};

Вот вариант C ++ 11 для произвольного количества параметров:

struct VoidNoOp {
    void operator()() const { };
    template<typename P1, typename... Params>
    void operator()(P1 p1, Params... parameters) {
        (void)(p1);             // we do this just to remove warnings -- requires the recursion
        operator()(parameters...);
    }
};

Проблема в том, что functor - это тип, определяемый вызывающей стороной, поэтому он может не иметь конструктора по умолчанию или любых других функций, на которые вы полагаетесь для создания значения по умолчанию.

Итак, можно ли использовать перегруженную функцию?

template<typename functor>
void foo(functor const& f)
{
       f(1, 2);
}

template<typename functor>
void foo()
{
}

Обертка функции, которая может сохранять NULL во время выполнения, - это std::function (C++11) или boost::function.

#include <functional>
#include <cstdio>

void foo(std::function<void(int, int)> f)
{
    if (f) {
       f(1, 2);
    }
}

void print(int a, int b) { std::printf("%d %d\n", a, b); }

int main()
{
   foo(0);
   foo(print);
}