Why won't this template compile?

Question

I have the following class used with MSVC2013 Update 4:

template <typename T>
class MyFunction;

template<typename R, class... Ts>
class MyFunction < R(Ts...) >
{
public:
    using func_type = R(*)(Ts...);

    MyFunction(func_type f)
        : m_func(f)
    {
    }

    R operator()(Ts ... args)
    {
        return m_func(args...);
    }

private:
    func_type m_func;
};

If I use it like so:

MyFunction<int (int)> f1(nullptr);
MyFunction<int __cdecl(int)> f2(nullptr);
MyFunction<int __stdcall(int)> f3(nullptr);

Why does f3 fail to compile? (Considering that __cdecl works!).

error C2079: 'f3' uses undefined class 'MyFunction<int (int)>'  
error C2440: 'initializing' : cannot convert from 'nullptr' to 'int'

The constructor takes a func_type, which is a function pointer, thus nullptr is fine? — paulm, Jan 22 '16 at 13:13
I suspect that `R(Ts...)` is implicitly `R __cdecl (Ts...)`, so that partial specialization doesn't match `int __stdcall(int)`. — T.C., Jan 22 '16 at 13:14
@T.C. if so would there be some way to pass the calling convention in? — paulm, Jan 22 '16 at 13:15
Write partial specializations for all calling conventions you care about. You may want to derive from an common base template. — T.C., Jan 22 '16 at 13:16
Have a look at http://stackoverflow.com/questions/5991507/template-partial-specialization-for-stdcall-function-pointer — Sander De Dycker, Jan 22 '16 at 13:26
@GuillaumeRacicot what do you mean? I should be using std::forward in operator()? — paulm, Jan 22 '16 at 14:59

score 2 · Accepted Answer · answered Jan 22 '16 at 13:26

In MSVC, the calling convention is part of the function type; the default calling convention is __cdecl, so R(Ts...) is really R __cdecl (Ts...) and doesn't match int __stdcall(int).

If you compile with /Gz, which makes the default calling convention __stdcall, you'd see an error on f2 instead.

You'll have to write partial specializations for all calling conventions you want to support:

template<class F, class R, class... Args>
class MyFunctionImpl {
public:
    using func_type = F*;

    MyFunctionImpl(func_type f)
        : m_func(f)
    {
    }

    R operator()(Args ... args)
    {
        return m_func(args...);
    }

private:
    func_type m_func;
};

template<typename R, class... Ts>
class MyFunction < R __cdecl(Ts...) >
    : MyFunctionImpl<R __cdecl(Ts...), R, Ts...> {
    using MyFunctionImpl<R __cdecl(Ts...), R, Ts...>::MyFunctionImpl;
};

template<typename R, class... Ts>
class MyFunction < R __stdcall(Ts...) >
    : MyFunctionImpl<R __stdcall(Ts...), R, Ts...> {
    using MyFunctionImpl<R __stdcall(Ts...), R, Ts...>::MyFunctionImpl;
};

// etc.

Why won't this template compile?

1 Answers1