In some cases, function overloading seems to create ambiguity. When the function contains multiple template arguments. Encountered on MSVC2015, and tested at : http://melpon.org/wandbox/permlink/mtfWJXEtQ8lEP8ub

template<class> struct A { };
template<template<class> class, class> struct B { };
template<class, class> struct C { };

template<template<class> class TT, class T, class U> void f(TT<T>, B<TT, T>, U) { }
template<template<class> class TT, class T, class V> void f(TT<T>, B<TT, T>, C<TT<T>, V>) { }

int main()
{
   A<int> a;
   B<A, int> b;
   C<A<int>, long> c;
   f(a, b, c);//ambiguity error
}

--------------------------------------------------
Another example :

template <class T>
class BX {
public :
    BX() {}
    ~BX() {}
};

template <class T1, class T2>
class G {
public :
    G() {}
    ~G() {}
};

template <template <class T> class T1, class T>
class DT {};

class B {
public :
    template <template <class T> class T1, class T, class M>
    static void func(const M& m, const DT<T1, T>* dt, T1<T>& val) {}

    template <template <class T> class T1, class T, class M>
    static void func(const G<T1<T>, M>& g, const DT<T1, T>* dt, T1<T>& val) {}

    //here is a small variation of func as a test
    template <template <class T> class T1, class T, class M>
    static void func2(const M& m, const DT<T1, T>* dt) {}

    template <template <class T> class T1, class T, class M>
    static void func2(const G<T1<T>, M>& g, const DT<T1, T>* dt) {}
};

int main() {
    BX< int > bx;
    G<BX< int >, int> g;
    DT<BX, int>* dt;
    B::func(g, dt, bx);//Error  C2668   'B::func': ambiguous call to overloaded function
    B::func2(g, dt);//no error
}

Problem also submitted at : http://stackoverflow.com/questions/39060180/c-templates-and-ambiguous-call-to-overloaded-function