c++ - std::forward 和 operator()

Question

我一直在考虑为我的 C++ 项目编写 static_if，我无意中发现了以下代码:

#include <iostream>
using namespace std;

namespace static_if_detail {

struct identity {
    template<typename T>
    T operator()(T&& x) const {
        return std::forward<T>(x);
    }
};

template<bool Cond>
struct statement {
    template<typename F>
    void then(const F& f){
        f(identity());
    }

    template<typename F>
    void else_(const F&){}
};

template<>
struct statement<false> {
    template<typename F>
    void then(const F&){}

    template<typename F>
    void else_(const F& f){
        f(identity());
    }
};

} //end of namespace static_if_detail

template<bool Cond, typename F>
static_if_detail::statement<Cond> static_if(F const& f){
    static_if_detail::statement<Cond> if_;
    if_.then(f);
    return if_;
}

template<typename T>
void decrement_kindof(T& value){
    static_if<std::is_same<std::string, T>::value>([&](auto f){
        f(value).pop_back();
    }).else_([&](auto f){
        --f(value);
    });
}


int main() {
    // your code goes here
    std::string myString{"Hello world"};
    decrement_kindof(myString);
    std::cout << myString << std::endl;
    return 0;
}

这一切对我来说都很有意义，除了一件事:struct identity 中的重载 operator()。它接受一个名为 x、cool 和 all 的 T 类型的 rhs。但是当 identity 被调用时，实际上没有任何东西传递给 identity。

template<typename F>
void then(const F& f){
    f(identity());
}

上面，f 调用了 identity，但没有传递任何东西给 identity。然而身份返回转发的参数(在我的例子中，一个 std::string)，并弹出字符串的最后一个字符。当身份本身没有传递给它转发的参数时，身份如何返回转发的参数？

Answer 1

f不打电话 identity - f使用 identity 的实例调用.在这里浏览两个案例:

static_if<std::is_same<std::string, T>::value>([&](auto f){
    f(value).pop_back();
}).else_([&](auto f){
    --f(value);
});

如果T是std::string , 然后我们实例化一个 statement<true>谁的then()使用 identity 的实例调用传入函数.第一个 lambda 的参数，f , 类型为 identity - 所以 f(value)真的只是value我们做value.pop_back() .

如果T不是 std::string , 然后我们实例化一个 statement<false>谁的then()什么都不做，谁的else_()使用 identity 的实例调用 lambda .再次f(value)只是value我们做--value .

---

这是一个非常令人困惑的 static_if 实现, 自 f在 lambda 中总是一个 identity .这是必要的，因为我们不能使用 value直接(不能写 value.pop_back()，因为那里没有从属名称，所以编译器会很高兴地确定它对整数来说格式不正确)，所以我们只是包装了 value 的所有用途在依赖函数对象中延迟实例化( f(value) 依赖于 f ，因此在提供 f 之前无法实例化 - 如果不调用该函数则不会发生)。

最好实现它，以便您实际将参数传递给 lambda。