Question

考虑以下代码和apply函数：

// Include
#include <iostream>
#include <array>
#include <type_traits>
#include <sstream>
#include <string>
#include <cmath>
#include <algorithm>

// Just a small class to illustrate my question
template <typename Type, unsigned int Size>
class Array
{
    // Class body (forget that, this is just for the example)
    public:
        template <class... Args> Array(const Args&... args) : _data({{args...}}) {;}
        inline Type& operator[](unsigned int i) {return _data[i];}
        inline const Type& operator[](unsigned int i) const {return _data[i];}
        inline std::string str() 
        { 
            std::ostringstream oss; 
            for (unsigned int i = 0; i < Size; ++i) 
                oss<<((*this)[i])<<" "; 
            return oss.str();
        }
    protected:
        std::array<Type, Size> _data;
    // Apply declaration
    public:
        template <typename Return, 
                  typename SameType, 
                  class... Args, 
                  class = typename std::enable_if<std::is_same<typename std::decay<SameType>::type, Type>::value>::type> 
        inline Array<Return, Size> apply(Return (*f)(SameType&&, Args&&...), const Array<Args, Size>&... args) const;
}; 

// Apply definition
template <typename Type, unsigned int Size>
template <typename Return, typename SameType, class... Args, class> 
inline Array<Return, Size> Array<Type, Size>::
apply(Return (*f)(SameType&&, Args&&...), const Array<Args, Size>&... args) const
{
    Array<Return, Size> result; 
    for (unsigned int i = 0; i < Size; ++i) {
        result[i] = f((*this)[i], args[i]...);
    }
    return result;
}

// Example
int main(int argc, char *argv[])
{
    Array<int, 3> x(1, 2, 3);
    std::cout<<x.str()<<std::endl;
    std::cout<<x.apply(std::sin).str()<<std::endl;
    return 0;
}

编译失败：

universalref.cpp: In function ‘int main(int, char**)’:
universalref.cpp:45:32: erreur: no matching function for call to ‘Array<int, 3u>::apply(<unresolved overloaded function type>)’
universalref.cpp:45:32: note: candidate is:
universalref.cpp:24:200: note: template<class Return, class SameType, class ... Args, class> Array<Return, Size> Array::apply(Return (*)(SameType&&, Args&& ...), const Array<Args, Size>& ...) const [with Return = Return; SameType = SameType; Args = {Args ...}; <template-parameter-2-4> = <template-parameter-1-4>; Type = int; unsigned int Size = 3u]
universalref.cpp:24:200: note:   template argument deduction/substitution failed:
universalref.cpp:45:32: note:   mismatched types ‘SameType&&’ and ‘long double’
universalref.cpp:45:32: note:   mismatched types ‘SameType&&’ and ‘float’
universalref.cpp:45:32: note:   mismatched types ‘SameType&&’ and ‘double’
universalref.cpp:45:32: note:   couldn't deduce template parameter ‘Return’

我不太清楚为什么会失败。在那段代码中，我想：

保持通用引用具有最通用的功能
可以使用语法apply(std::sin)

那么我需要做些什么才能让它编译？

Answer 1

功能std::sin的

Several overloads exist，您的功能模板无法推断出会产生完全匹配的功能（在大多数情况下，不会考虑任何转化时）推导模板参数）。

首先，这些重叠中没有一个接受引用到它们的第一个（也是唯一的）参数。编译器告诉你这一点，因此Return和SameType不能从参数类型f中推断出来：

universalref.cpp:24:200: note:   template argument deduction/substitution failed:
universalref.cpp:45:32: note:   mismatched types ‘SameType&&’ and ‘long double’
universalref.cpp:45:32: note:   mismatched types ‘SameType&&’ and ‘float’
universalref.cpp:45:32: note:   mismatched types ‘SameType&&’ and ‘double’

因此，第一步是更改apply()功能模板的签名：

[...] apply(Return (*f)(SameType, Args&&...), [...]
                        ^^^^^^^^
                        No URef!

此外，SFINAE正在消除函数模板的所有实例化，其中Return未推断为int（您在apply()的实例上调用Array<int, 3>：遗憾的是，std::sin的现有重载都没有int作为返回类型。

您可以尝试将实例化更改为Array<double, 3>，但不幸的是，由于C ++ 11标准的第14.8.2 / 5段规定：

非推断的上下文是：

- 使用qualified-id。
指定的类型的嵌套名称说明符
- 非类型模板参数或子表达式引用模板的数组   参数。

- 在具有默认参数的函数参数的参数类型中使用的模板参数   在正在进行参数推断的调用中使用。

- 函数参数，由于关联函数，无法进行参数推导   argument是一个函数，或重载函数集（13.4），并且以下一个或多个适用：


- 多个函数匹配函数参数类型（导致模糊推理）或

- 没有函数匹配函数参数类型，或

- 作为参数提供的函数集包含一个或多个函数模板。

由于需要支持整数类型的重载（这是C + 11中的新增功能，请参阅26.8 / 11），您的库实现很可能定义了std::sin的模板重载。这就是stdlibc ++的定义：

template<typename _Tp>
inline _GLIBCXX_CONSTEXPR
typename __gnu_cxx::__enable_if<__is_integer<_Tp>::__value, 
                                double>::__type
sin(_Tp __x)
{ return __builtin_sin(__x); }

有办法离开这里，但你可能不喜欢它们。除了上述必要（但不充分）的更改之外，您还需要将std::sin显式转换为所需类型。我也会在这里删除SFINAE条件，因为除了强制SameType等于Type之外它没有做任何其他事情：

// Declaration in the `Array` class
template <typename Return, class... Args>
inline Array<Return, Size> apply(
    Return (*f)(Type, Args&&...), 
    const Array<Args, Size>&... args
    ) const;

[...]

// Example
int main(int argc, char *argv[])
{
    Array<double, 3> x(1, 2, 3);
    //    ^^^^^^
    //    NOTICE
    //     THIS

    std::cout<<x.str()<<std::endl;

    std::cout<<x.apply((double(*)(double))std::sin).str()<<std::endl; // OK
    //                 ^^^^^^^^^^^^^^^^^^^
    //                     NOTICE THIS

    return 0;
}

模板，可变参数功能，通用参考和功能指针：爆炸性的鸡尾酒

1 个答案: