模板类中的模板转换运算符 - 到函数指针

Question

I'm trying to make my class be convertible to a function pointer, for a slew of reasons unrelated to this post.

When I try to do this with a non-template class, it works fine. Below, Bar bar; bar(1) Bar bar; bar(1) correctly compiles, and segfaults as-expected. But Foo<int>; foo(1) Foo<int>; foo(1) doesn't compile at all.

I've tried multiple compilers, and I get: mismatched types 'Args' and 'int'

Any ideas? Live demo: https://wandbox.org/permlink/alSGBssfSd4pHgdl

#include <iostream>
#include <tuple>

using namespace std;

template<typename... Args>
using Test = void(*)(Args...);

template<typename T>
struct Foo {
    template<typename... Args>
    operator Test<Args...>() {
        return Test<Args...>{};
    }
};

struct Bar {
    template<typename... Args>
    operator Test<Args...>() {
        return Test<Args...>{};
    }
};

int main()
{
    Foo<int> foo;
    // foo(1);
    
    Bar bar;
    bar(1);
    
    return 0;
}

Tried this awful syntax, too:

    template<typename... Args>
    (*operator void() const)(Args...) {
      return {};
    }

Answer 1

You can try this:

#include <iostream>
#include <tuple>

using namespace std;

template<typename... Args>
using Test = void(*)(Args...);

template<typename T>
struct Foo {
    template<typename... Args>
    operator Test<Args...>()
    {
        std::cout << __FUNCTION__ << std::endl;
        return Test<Args...>{};
    }
};

struct Bar {
    template<typename... Args>
    operator Test<Args...>()
    {
        std::cout << __FUNCTION__ << std::endl;
        return Test<Args...>{};
    }
};

int main()
{
    Foo<int> foo;
    auto x = static_cast<Test<int, double>>(foo);

    Bar bar;
    auto y = static_cast<Test<char, float>>(bar);

    return 0;
}

When using Visual C++ 2019, I get the following run-time output:

Foo<int>::operator void (__cdecl *)(int,double)
Bar::operator void (__cdecl *)(char,float)

The use of the static_cast is to force the usage of the overloaded operator member functions.

Answer 2

Alternatively, you can also try:

#include <iostream>
#include <tuple>
#include <type_traits>

using namespace std;

template<typename... Args>
using Test = void(*)(Args...);

template<typename T>
struct Foo {
    template<typename... Args>
    Test<Args...> operator()(int x)
    {
        return Test<Args...>{};
    }
};

struct Bar {
    template<typename... Args>
    Test<Args...> operator()(int x)
    {
        return Test<Args...>{};
    }
};

int main()
{
    Foo<int> foo;

    auto w = foo.template operator()<int, double>(1);
    std::cout << "w: " << typeid(w).name() << std::endl;

    auto x = foo(2);
    std::cout << "x: " << typeid(x).name() << std::endl;


    Bar bar;

    auto y = bar.template operator()<char, float>(3);
    std::cout << "y: " << typeid(y).name() << std::endl;

    auto z = bar(4);
    std::cout << "z: " << typeid(z).name() << std::endl;

    return 0;
}

When using Visual C++ 2019, I get the following run-time output:

w: void (__cdecl*)(int,double)
x: void (__cdecl*)(void)
y: void (__cdecl*)(char,float)
z: void (__cdecl*)(void)

In this way, the object is now callable and returns a function pointer.