只返回传递值的默认函数？

Question

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

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*/ 和/*SOMETHING 2*/？

Answer 1

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

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);
    }
}

Answer 2

这称为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 的版本。

Answer 3

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);
  }
}

Answer 4

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

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);
  }
}

Answer 5

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))

Answer 6

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

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
}