Enterprise FizzBuzz in C++11 I've decided to write a C++ FizzBuzz with the focus on some new C++11 features, ridiculous optimizations and unit-testability.

Are there improvement possibilities in those regards?

template &lt;typename T&gt;
static void fizzbuzz(std::ostream&amp; out, const T&amp; number, const std::vector&lt;std::pair&lt;std::string, T&gt;&gt;&amp; values)
{
    bool found = false;

    std::for_each(values.begin(), values.end(),
        [&amp;](decltype(*values.begin()) i)
        {
            if (0 == number % i.second)
            {
                out &lt;&lt; i.first.c_str();
                found = true;
            }        
        }
    );

    if (!found)
    {
        out &lt;&lt; number;
    }
}

template &lt;typename T&gt;
static void filter_fizzbuzz(const T&amp; end, std::vector&lt;std::pair&lt;std::string, T&gt;&gt;&amp; values)
{
    // Needs to be sorted as the filtering only looks for divisible numbers up to the current one
    std::sort(values.begin(), values.end());

    for (auto i = values.begin(); i != values.end();)
    {
        // i &gt; end will never become 0
        if (i-&gt;second &gt; end)
        {
            i = values.erase(i);
            continue;
        }

        // Is the current number already handled by a divisor?
        bool alreadyHandled = false;
        for (auto j = values.begin(); j != i; j++)
        {
            if (0 == i-&gt;second % j-&gt;second)
            {
                alreadyHandled = true;
            }
        }

        if (!alreadyHandled)
        {
            i++;
            continue;
        }

        i = values.erase(i);
    }
}


template &lt;typename T&gt;
void fizzbuzz(std::ostream&amp; out, const T&amp; start, const T&amp; end, std::vector&lt;std::pair&lt;std::string, T&gt;&gt;&amp; values)
{
    if (start &gt; end)
        throw std::out_of_range("start &gt; end");
    if (!values.size())
        return;

    filter_fizzbuzz(end, values);
    for (T i = start; i &lt; end; i++)
    {
        fizzbuzz(out, i, values);
        out &lt;&lt; std::endl;
    }
}
Know when to use which feature

C++11 offers range based for loops so you should use them instead of for_each with lambdas:

for(auto i: values) {
    if (0 == number % i.second) {
        out &lt;&lt; i.first.c_str();
        found = true;
    }        
}


As you can see this facilitates auto instead of the ugly decltype hack.

Don't overuse static

Why are all the functions declared static? Are they part of a class?
If so, why?

Design: Unnecessary complexity

I have troubles tracing the algorithm in your code.
If you would really want an enterprise solution I would try to integrate with standards like iterators and function(/functor) interfaces that can be passed into algorithms like std::transform.