13

作为一个懒惰的开发者，我喜欢使用这个技巧来指定一个默认函数：

template <class Type, unsigned int Size, class Function = std::less<Type> >
void arrange(std::array<Type, Size> &x, Function&& f = Function())
{
    std::sort(std::begin(x), std::end(x), f);
}

但在一个非常特殊的情况下，我遇到了一个问题，如下所示：

template <class Type, unsigned int Size, class Function = /*SOMETHING 1*/>
void index(std::array<Type, Size> &x, Function&& f = /*SOMETHING 2*/)
{
    for (unsigned int i = 0; i < Size; ++i) {
        x[i] = f(i);
    }
}

在这种情况下，我希望默认函数相当于：（[](const unsigned int i){return i;}一个只返回传递值的函数）。

为了做到这一点，我必须写什么而不是/*SOMETHING 1*/and /*SOMETHING 2*/？

4

6 回答 6

19

没有标准的函子可以做到这一点，但它很容易编写（尽管确切的形式存在争议）：

struct identity {
    template<typename U>
    constexpr auto operator()(U&& v) const noexcept
        -> decltype(std::forward<U>(v))
    {
        return std::forward<U>(v);
    }
};

这可以按如下方式使用：

template <class Type, std::size_t Size, class Function = identity>
void index(std::array<Type, Size> &x, Function&& f = Function())
{
    for (unsigned int i = 0; i < Size; ++i) {
        x[i] = f(i);
    }
}
于 2013-03-04T13:25:53.763 回答
3

这称为identity函数。不幸的是，它不是 C++ 标准的一部分，但您可以轻松地自己构建一个。

如果你碰巧使用 g++，你可以用-std=gnu++11然后激活它的扩展

#include <array>
#include <ext/functional>

template <class Type, std::size_t Size, class Function = __gnu_cxx::identity<Type> >
void index(std::array<Type, Size> &x, Function&& f = Function())
{
    for (unsigned int i = 0; i < Size; ++i) {
        x[i] = f(i);
    }
}

也许它将在 C++20 中可用，请参阅std::identity. 在那之前，您可以在boost::compute::identity查看 boost 的版本。

于 2013-03-04T13:22:45.850 回答
2

boost::phoenix 提供了一个完整的功能工具箱，这里的 'arg1' 是身份的 ident ;-)

#include <boost/phoenix/core.hpp>

template <class X, class Function = decltype(boost::phoenix::arg_names::arg1)>
void index(X &x, Function f = Function()) {
    for (std::size_t i = 0; i < x.size(); ++i) {
            x[i] = f(i);
  }
}
于 2013-03-04T15:14:56.187 回答
1

您可以构建自己的身份函子：

template <typename T>
class returnIdentifyFunctor
{
  public:
     auto operator ()(  T &&i ) -> decltype( std::forward<T>(i) )
    {
      return std::move(i);
    }
};

template <class Type, unsigned int Size, class Function = returnIdentifyFunctor<Type>>
void index(std::array<Type, Size> &x, Function&& f = Function() )
 {
    for (unsigned int i = 0; i < Size; ++i) {
            x[i] = f(i);
  }
}
于 2013-03-04T13:24:03.427 回答
1

boost 有以下变体：

template <class Type, unsigned int Size, class Function = boost::function<Type(Type)>>
void index(std::array<Type, Size> &x, Function&& f = boost::bind(std::plus<Type>(), 0, _1))
于 2020-02-11T18:18:22.510 回答
0

解决此问题的一种方法是具有两个不同的功能。我发现不使用默认参数是很明智的。

template <class Type, unsigned int Size, class Function>
void index(std::array<Type, Size> &x, Function&& f){
    for(unsigned int i = 0; i < Size; ++i) x[i] = f(i);
}

template<class Type, unsigned int Size>
void index(std::array<Type, Size> &x){
    return index(x, [](unsigned int i){return i;});                      // C++11 in this case
                //, [](auto&& e){return std::forward<decltype(e)>(e)};); // C++14 in a more general case
                //, std::identity); // C++20 in general
}
于 2018-12-25T00:15:43.757 回答