Question

我通过转发玩了一下，得到以下示例，该工作正常。

void Func2( int& a, int& b) { cout << "V1" << endl; }
void Func2( int&& a, int& b) { cout << "V2" << endl; }
void Func2( int& a, int&& b) { cout << "V3" << endl; }
void Func2( int&& a, int&& b) { cout << "V4" << endl; }

    template < typename T, typename U>
void Func( T&& t, U&& u) 
{
    X::Func3( std::forward<T>(t), std::forward<U>(u));
    Func2( std::forward<T>(t), std::forward<U>(u));
}

int main()
{
    int a, b;
    Func( a, b);
    Func( 1, b);
    Func( a, 2);
    Func( 1, 2);

    return 0;
}

但我想要Func2的函数模板用任何类型替换类型int，或者如果不可能用专门方法替换类。以下代码片段将无法编译：

class X
{
    public: 
        template < typename T, typename U>
            static void Func3( T& t, U& u) { cout << "X1" << endl; }

        template < typename T, typename U>
            static void Func3( T&& t, U& u) { cout << "X2" << endl; }

        template < typename T, typename U>
            static void Func3( T& t, U&& u) { cout << "X3" << endl; }

        template < typename T, typename U>
            static void Func3( T&& t, U&& u) { cout << "X4" << endl; }
};

结果：

main.cpp: In instantiation of 'void Func(T&&, U&&) [with T = int&; U = int&]':
main.cpp:36:18:   required from here
main.cpp:29:57: error: call of overloaded 'Func3(int&, int&)' is ambiguous
         X::Func3( std::forward<T>(t), std::forward<U>(u));
                                                         ^
main.cpp:29:57: note: candidates are:
main.cpp:9:29: note: static void X::Func3(T&, U&) [with T = int; U = int]
                 static void Func3( T& t, U& u) { cout << "X1" << endl; }
                             ^
main.cpp:12:29: note: static void X::Func3(T&&, U&) [with T = int&; U = int]
                 static void Func3( T&& t, U& u) { cout << "X2" << endl; }
                             ^
main.cpp:15:29: note: static void X::Func3(T&, U&&) [with T = int; U = int&]
                 static void Func3( T& t, U&& u) { cout << "X3" << endl; }
                             ^
main.cpp:18:29: note: static void X::Func3(T&&, U&&) [with T = int&; U = int&]
                 static void Func3( T&& t, U&& u) { cout << "X4" << endl; }
                             ^

Answer 1

以下可能会有所帮助：

template <typename T, typename U>
class X
{
public:
    static void Func3(T& t, U& u) { cout << "X1" << endl; }
    static void Func3(T&& t, U& u) { std::cout << "X2" << std::endl; }
    static void Func3(T& t, U&& u) { cout << "X3" << endl; }
    static void Func3(T&& t, U&& u) { cout << "X4" << endl; }
};

template <typename T, typename U>
void Func(T&& t, U&& u)
{
    X<typename std::decay<T>::type, typename std::decay<U>::type>::Func3( std::forward<T>(t), std::forward<U>(u));
    Func2( std::forward<T>(t), std::forward<U>(u));
}

所以Func3使用真正的r值引用而不是通用引用。

Answer 2

正如其他答案所说，调用是不明确的，因为通用引用T&&, U&&匹配左值和右值引用。您可以使用std::enable_if手动删除歧义，例如

template <bool C>
using only_if = typename std::enable_if <C>::type;

template <typename T>
using is_lref = std::is_lvalue_reference <T>;

struct X
{
    template <typename T, typename U>
    static void
    Func3(T& t, U& u) { cout << "X1" << endl; }

    template <typename T, typename U>
    static only_if <!is_lref <T>()>
    Func3(T&& t, U& u) { cout << "X2" << endl; }

    template <typename T, typename U>
    static only_if <!is_lref <U>()>
    Func3(T& t, U&& u) { cout << "X3" << endl; }

    template <typename T, typename U>
    static only_if <!(is_lref <T>() || is_lref <U>())>
    Func3(T&& t, U&& u) { cout << "X4" << endl; }
};

另见live example。这样你明确地说T&&不应该与左值参考匹配。

这种方法很难推广到更多的输入参数。在这种情况下，请考虑一次只处理一个参数，将剩余的参数保留为rvalue-references。因此，您只需要两次重载和递归调用，但确切的形式取决于您想要做什么。

Answer 3

这是因为T＆amp;＆amp;在模板函数中非常特殊，并且不是右值引用。它被命名为通用引用并绑定到参数的类型。因此，Func3的几个候选者导致相同的绑定，并且你以一个模糊的调用结束。

下面的代码显示“true false true”并显示通用引用的行为。

#include <iostream>
#include <type_traits>

template <typename T> 
bool foo( T&& v ) {
    return std::is_rvalue_reference<decltype(v)>::value;
}

int main() {
    std::cout << std::boolalpha;
    std::cout << foo( 1 ) << std::endl;
    int a{};
    std::cout << foo( a ) << std::endl;
    std::cout << foo( std::move(a) ) << std::endl;
}

const T＆amp;的超载和T＆amp;＆amp;只是不是一个很好的解决方案，因为T＆amp;＆amp;将比const T＆amp;更好地匹配。这与非模板函数不同。

#include <iostream>
#include <type_traits>

template <typename T> 
bool foo( T&& v ) {
    return false;
}

template <typename T> 
bool foo( T const & v ) {
    return true;
}

bool bar( int&& v ) {
    return false;
}

bool bar( int const & v ) {
    return true;
}

int main() {
    std::cout << std::boolalpha;
    int a{};
    int const b {};
    std::cout << foo( a ) << std::endl; // false
    std::cout << foo( b ) << std::endl; // true

    std::cout << bar( a ) << std::endl; // true
    std::cout << bar( b ) << std::endl; // true
}

rvalue和左值引用的模板特化

3 个答案: