强制模板类型通过推导被引用

Question

假设我有一个函数func：

template<typename T>
auto func(T arg){
    std::cout << std::boolalpha;
    std::cout << "T is ref: " << std::is_reference<T>::value << '\n';
}

有没有一种方法可以强制将T 推断为引用类型，而无需显式指定模板参数？

就像能够写出这样的东西：

auto main() -> int{
    auto x = 5;
    func(std::ref(x));
}

但不必专门针对std::reference_wrapper。

static_casting 不会阻止 int& 衰减为 int for T。

假设我不能更改函数签名。

Answer 1

假设我无法更改函数签名。

签名

template<typename T>
auto func(T arg) { ... }

永远不会推断引用，因为类型推断适用于参数表达式的类型，并且来自 [expr]：

如果表达式最初的类型为“引用T”（8.3.2、8.5.3），则该类型在之前调整为T 任何进一步的分析。

也就是说，模板推导仅在未明确提供模板参数时发生。所以你可以明确指定T：

auto main() -> int{
    auto x = 5;
    func<int&>(x); // T = int&
}

否则，您可以在两者之间添加一个中间步骤：

template <typename T>
auto func_helper(T&& arg) {
    return func<T>(std::forward<T>(arg));
               ↑↑↑
}

因为，在 [temp.deduct.call]：

如果 P 是转发引用并且参数是 lvalue，类型“对A的左值引用”用于代替A进行类型推导。

所以如果func_helper被一个左值调用，模板参数P会被推导出来作为引用。在您的示例中：

func_helper(x);

T 将被推导出为int&，因此我们显式调用与之前相同的函数：func<int&>。

func_helper(5);

T 会被推导出为int，我们会调用func<int>，就像我们直接调用func 一样。

Answer 2

注意：此答案已因后期编辑声明 OP 无法修改该功能而失效。

---

类型推导和引用折叠是你需要的：

template<class T>
auto func(T&&) {
    std::cout << std::boolalpha << "T is ref: " << std::is_reference<T>::value << '\n';
}

int main() {
    func(5);
    int i = 7;
    func(i);
    int const j = 9;
    func(j);
}

输出：

T is ref: false
T is ref: true
T is ref: true

Answer 3

#include <iostream>
#include <type_traits>
#include <iomanip>

using namespace std;


template<typename T>
auto func(T arg)
{
    std::cout << std::boolalpha;
    std::cout << "T if ref: " << std::is_reference<decltype(arg)>::value << "\n";
}

template<class T>
auto func_wrapper(T& arg)
{
    func<T&>(arg);
}

#define func func_wrapper

auto main() -> int
{
    auto x = 5;
    func(x);

    auto& y = x;
    func(y);

    return 0;
}

预期输出（原文如此）：

T if ref: true
T if ref: true