C++ 间接转发引用

众所周知，“直接”转发引用的工作方式很简单：

template<typename T>
void f(T &&t); // Here we are.

模板
无效f（T&T）；//我们到了。

现在，如何以间接方式使用转发引用：

template<typename T>
void f(some_class_template<T> &&f); // Here it is an rvalue reference and not universal one

模板
void f（某些类模板&&f）；//这里它是右值引用，而不是通用引用

---

在第二种情况下，是否有办法获得转发引用？

否，这是不可能的。如果要将函数约束为仅接受某个类模板，则必须使用类型特征：

template <typename T>
struct is_some_class_template
    : std::false_type
{};

template <typename T>
struct is_some_class_template<some_class_template<T>>
    : std::true_type
{};

模板
struct是一些类模板
：std:：false\u类型
{};
样板
struct是一些类模板
：std:：true\u类型
{};

这种特性可以用几种方式使用。一个是SFINAE：

template <typename T,
    std::enable_if_t<is_some_class_template<std::decay_t<T>>::value, int> = 0>
void f(T&& f); // f is some_class_template<U> for some U

模板
无效f（T&f）；//f是某个类的模板

或者，您可能会发现标签调度更可取：

template <typename T>
void f_impl(T&& f, std::true_type); // f is some_class_template<U> for some U

template <typename T>
void f_impl(T&& f, std::false_type); // f is something else

template <typename T>
void f(T&& f) {
    return f_impl(std::forward<T>(f), is_some_class_template<std::decay_t<T>>{});
}

模板
void f_impl（T&f，std:：true_type）；//f是某个类的模板
样板
void f_impl（T&f，std:：false_type）；//f是另外一回事
样板
无效f（T&f）{
返回f_impl（std:：forward（f），是某个类的模板{}）；
}

不，这是不可能的。如果要将函数约束为仅接受某个类模板，则必须使用类型特征：

template <typename T>
struct is_some_class_template
    : std::false_type
{};

template <typename T>
struct is_some_class_template<some_class_template<T>>
    : std::true_type
{};

模板
struct是一些类模板
：std:：false\u类型
{};
样板
struct是一些类模板
：std:：true\u类型
{};

这种特性可以用几种方式使用。一个是SFINAE：

template <typename T,
    std::enable_if_t<is_some_class_template<std::decay_t<T>>::value, int> = 0>
void f(T&& f); // f is some_class_template<U> for some U

模板
无效f（T&f）；//f是某个类的模板

或者，您可能会发现标签调度更可取：

template <typename T>
void f_impl(T&& f, std::true_type); // f is some_class_template<U> for some U

template <typename T>
void f_impl(T&& f, std::false_type); // f is something else

template <typename T>
void f(T&& f) {
    return f_impl(std::forward<T>(f), is_some_class_template<std::decay_t<T>>{});
}

模板
void f_impl（T&f，std:：true_type）；//f是某个类的模板
样板
void f_impl（T&f，std:：false_type）；//f是另外一回事
样板
无效f（T&f）{
返回f_impl（std:：forward（f），是某个类的模板{}）；
}