c++ - 如何解决以下代码中的函数重载歧义

Question

假设 int 和 double 有函数重叠。

void Print(int v)
{
    cout << v << endl;
}

void Print(double v)
{
    cout << v << endl;
}

有一个函数旨在作为上述函数中的一个可调用函数传入。

template<typename FnT>
void Function(int v, FnT&& fn)
{
    fn(v);
}

但是下面的代码是有歧义的:

Function(1, Print);

Live example

编译器无法推断第二个参数的类型。这很容易解决:

Function(1, static_cast<void(*)(int)>(Print));

我相信存在更通用和优雅的方法来解决这个问题。当添加函数重载时，STL 算法中可能会出现此问题。

vector<int> v = { 1,2,3 };
for_each(v.begin(), v.end(), Print); // ambigous code

如何以漂亮的方式解决这个问题？

Answer 1

将其包装在一个函数对象中:

#include <iostream>
#include <utility>

void Print(int v)
{
    std::cout << v << std::endl;
}

void Print(double v)
{
    std::cout << v << std::endl;
}

template<typename FnT>
void Function(int v, FnT&& fn)
{
    fn(v);
}

auto print_wrapper() {
    return [](auto&&...args) -> decltype(auto)
    {
        return Print(std::forward<decltype(args)>(args)...);
    };
}

int main()
{
    Function(1, print_wrapper());
}

从理论上讲，我们在这里所做的是使用绷带修复损坏的设计。

更好的设计是定义 Print 的概念作为模板函数对象。然后我们可以对其进行专门化，并根据我们的心意对其进行定制。

一个(非常完整的)模型是 boost::hash<>这值得任何人花半天的时间作为学习练习。

一个简单的例子:

#include <iostream>
#include <utility>
#include <string>

struct Printer
{
    void operator()(const int& i) const {
        std::cout << i << std::endl;
    }

    void operator()(const double& i) const {
        std::cout << i << std::endl;
    }

    template<class Anything>
    void operator()(const Anything& i) const {
        custom_print(i);
    }
};

struct Foo
{

};
void custom_print(Foo const& f) 
{
    std::cout << "a Foo" << std::endl;
}

template<typename X, typename FnT>
void Function(X const& x, FnT&& fn)
{
    fn(x);
}

int main()
{
    Function(1, Printer());
    Function(1.0, Printer());
    Function(Foo(), Printer());
}