std：：函数作为模板参数

Question

我目前有一个映射 ，但是为了灵活性，我希望能够分配一个lambda表达式，将std::wstring作为映射中的值返回。

所以我创建了这个模板类：

template <typename T>
class ValueOrFunction
{
private:
    std::function<T()> m_func;
public:
    ValueOrFunction() : m_func(std::function<T()>()) {}
    ValueOrFunction(std::function<T()> func) : m_func(func) {}
    T operator()() { return m_func(); }
    ValueOrFunction& operator= (const T& other)
    {
        m_func = [other]() -> T { return other; };
        return *this;
    }
};

并像这样使用它：

typedef ValueOrFunction<std::wstring> ConfigurationValue;
std::map<int, ConfigurationValue> mymap;

mymap[123] = ConfigurationValue([]() -> std::wstring { return L"test"; });
mymap[124] = L"blablabla";
std::wcout << mymap[123]().c_str() << std::endl; // outputs "test"
std::wcout << mymap[124]().c_str() << std::endl; // outputs "blablabla"

ValueOrFunction& operator= (const std::function<T()>& other)
{
    m_func = other;
    return *this;
}

IntelliSense提供了更多信息：

多个操作符“=”匹配这些操作数：function“valueorfunction::operator=(const std::function&other)[with T=std::wstring]”function“valueorfunction::operator=(const T&other)[with T=std::wstring]”操作数类型是:ConfigurationValue=const wchar_t[10]c:\projects\beta\CppTest\CppTest.cpp 37 13 CppTest

所以，我的问题是，为什么编译器不能区分std::function 和t？我该怎么解决这个问题？

Answer 1

基本问题是std::function有一个贪婪的隐式构造函数，它将试图转换任何内容，但在主体中编译失败。因此，如果您想用它重载，要么不允许转换为替代方案，要么您需要禁用可以转换为替代方案的东西，以调用std::function重载。

最简单的技术是标签分派。创建一个贪婪的operator=，并设置为完美的转发，然后手动分派到一个带有标记的assign方法：

 template<typename U>
 void operator=(U&&u){
   assign(std::forward<U>(u), std::is_convertible<U, std::wstring>());
 }
 void assign(std::wstring, std::true_type /*assign_to_string*/);
 void assign(std::function<blah>, std::false_type /*assign_to_non_string*/);

基本上，我们正在做手动过载解决方案。

如果有多个不同的类型与std::function竞争，则必须手动分派所有类型。解决这个问题的方法是测试您的类型u是否可以调用，并且结果是否可以转换为t，然后将其标记为dispatch。将非std::function重载保留在alternative分支中，并对其他所有内容进行常规的传统重载。

这里有一个细微的区别，既可转换为std::wstring的类型，又可调用返回可转换为t的内容的类型，最终会被分派到与上面最初的简单解决方案不同的重载，因为所使用的测试实际上并不是互斥的。为了完全手动模拟C++重载（针对std::function的愚蠢进行了更正），您需要使这种情况变得模棱两可！

最后一个高级操作是使用auto和尾随返回类型来提高其他代码检测=是否有效的能力。就我个人而言，在C++14之前，我不会这么做，除非是在胁迫下，除非我在写一些严肃的库代码。