Question

我想将std :: function存储在一个类中作为成员在调用 a.callMethod（）时，我遇到了以下测试代码的麻烦，其中方法已经在 a.setMethod（）之前设置。如果我删除模板，代码工作正常我试图使用函数callMethodOutsideClass进行调试但没有成功有没有更好的方法来管理它？

#include <iostream>
#include <vector>
#include <functional>

template<typename T>
struct A
{
    A(size_t size, T value) : vec_(size, value), method_(nullptr) {}
    void setMethod(const std::function<int(A<T>&)> method)  { method_ = method; }
    int callMethod()
    {
        if(method_)
            return method_(*this);
        else
            std::cerr << "method not initialized" << std::endl;
        return -1;
    }

    std::vector<int> vec_;
    std::function<int(A<T>& a)> method_;
};

template<typename T>
int callMethodOutsideClass(struct A<T>& a, const std::function<int(A<T>&)> method)
{
    return method(a);
}

template<typename T>
int apple(struct A<T>& a)
{
    a.vec_[0] += 1;
    return 1;
}

template<typename T>
int orange(struct A<T>& a)
{
    a.vec_[0] += 2;
    return 2;
}

int main()
{
    A<int> a(10,4), b(10,4);
    std::cout << callMethodOutsideClass(a, &apple) << std::endl;

    a.setMethod(&orange);
    std::cout << a.callMethod() << std::endl;

    std::cout << a.vec_[0] << std::endl;
}

我目前收到以下错误：

Foo6.cpp: In function ‘int main()’:
Foo6.cpp:46:47: error: cannot resolve overloaded function ‘apple’ based on conversion to type ‘std::function<int(A<int>&)>’
  std::cout << callMethodOutsideClass(a, &apple) << std::endl;
                                               ^
Foo6.cpp:48:21: error: no matching function for call to ‘A<int>::setMethod(<unresolved overloaded function type>)’
  a.setMethod(&orange);
                     ^
Foo6.cpp:48:21: note: candidate is:
Foo6.cpp:9:7: note: void A<T>::setMethod(std::function<int(A<T>&)>) [with T = int]
  void setMethod(const std::function<int(A<T>&)> method)  { method_ = method; }
       ^
Foo6.cpp:9:7: note:   no known conversion for argument 1 from ‘<unresolved overloaded function type>’ to ‘std::function<int(A<int>&)>’

Answer 1

指向函数的指针不是 a std::function<T>。无法基于作为参数给出的函数地址推导出std::function<T>签名。此外，当请求转换为std::function<T>时，编译器无法解析正确的函数模板特化以获取其地址，因为std::function<T>的构造函数也是函数模板。

你需要更明确：

std::cout << callMethodOutsideClass<int>(a, &apple<int>) << std::endl;
//                                 ^^^^^          ^^^^^
a.setMethod(&orange<int>);
//                 ^^^^^

有没有办法“轻松”推断出模板参数？

您可以通过以下两种方式之一修改callMethodOutsideClass的签名：

选项＃1：

禁用std::function<int(A<T>&)>参数的类型扣除：

template <typename T> struct identity { using type = T; };

template<typename T>
int callMethodOutsideClass(A<T>& a, const typename identity<std::function<int(A<T>&)>>::type method)
{
    return method(a);
}

但是您必须为std::function应用的类型删除付费。

选项＃2：

让编译器推导出作为参数给出的仿函数对象的实际类型：

template <typename T, typename F>
int callMethodOutsideClass(A<T>& a, F&& method)
{
    return std::forward<F>(method)(a);
}

在这两种情况下你都可以说：

callMethodOutsideClass(a, &apple<int>);
//                              ^^^^^

注意：您仍然需要通过提供模板参数列表&apple<int>来传递具体函数模板特化的地址。如果你想要使用简单的&address语法，那么接受它的函数需要声明该参数的确切类型：

template<typename T>
int callMethodOutsideClass(A<T>& a, int(*method)(A<T>&))
{
    return method(a);
}

callMethodOutsideClass(a, &apple);

或者您可以帮助编译器解决呼叫站点的正确过载：

callMethodOutsideClass(a, static_cast<int(*)(decltype(a)&)>(&apple));

...或者，您可以使用如下定义的lambda表达式：

template<typename T, typename F>
int callMethodOutsideClass(struct A<T>& a, F&& method)
{
    return std::forward<F>(method)(a);
}

// in C++11:
callMethodOutsideClass(a, [](decltype(a)& x){return apple(x);});
// in C++14:
callMethodOutsideClass(a, [](auto&& x){return apple(std::forward<decltype(x)>(x));});

就setMethod成员函数而言，事情更容易，因为编译器确切地知道它期望const std::function<int(A<T>&)> method已知T（未推断）。所以基本上，你只需要帮助编译器在调用站点获取你需要的函数模板特化的地址：

a.setMethod(&orange<int>);
a.setMethod(static_cast<int(*)(decltype(a)&)>(&orange));

模板std :: function作为类成员函数C ++

1 个答案:

选项＃1：

选项＃2：