Why does `std::forward` disable template argument deduction in Visual Studio 2010?

Disabling Template Argument Deduction in std::forward

Problem Statement

Visual Studio 2010 defines std::forward to disable template argument deduction. Why is this disabling intentional?

Answer

Template argument deduction would lead to incorrect type determination and wrong behavior in std::forward. Here's how:

Case Without Template Argument Deduction

Without template argument deduction, std::forward is defined as:

<code class="cpp">template<class _Ty> inline
_Ty&amp;&amp; forward(typename identity<_Ty>::type&amp; _Arg) {
    return ((_Ty&amp;&amp;)_Arg);
}</code>

Case With Template Argument Deduction

If std::forward used template argument deduction, the following scenarios would arise:

• For an rvalue reference to an object of type X (e.g., func() or 7), template argument deduction would correctly determine T as X.
• For an lvalue or const lvalue (e.g., objects with names), template argument deduction would incorrectly determine T as an lvalue reference or const lvalue reference.

Implications of Incorrect Type Determination

In perfect forwarding, the argument passed to std::forward is an lvalue. If template argument deduction were enabled, the deduced type T would be an lvalue reference. However, "perfect forwarding" implies an rvalue reference.

The cast in std::forward, static_cast(arg), would always collapse to an lvalue reference, even when the original argument was an rvalue. This would lead to incorrect casting and malfunctioning of the perfect forwarding mechanism.

Example

The following code demonstrates the issues with template argument deduction:

<code class="cpp">template<typename T>
T&& forward_with_deduction(T&& obj) {
    return static_cast<T&&>(obj);
}

int main() {
    int x;
    int& y = x;
    int&& z = std::move(x);

    forward_with_deduction(7); // Correctly calls forward(int&&)
    forward_with_deduction(y); // Incorrectly calls forward(int&)

    std::forward<int&>(y); // Correctly calls forward(int&)
}</code>

Conclusion

Disabling template argument deduction in std::forward is crucial for perfect forwarding to function correctly. It prevents erroneous type determination and ensures that rvalue references are correctly forwarded as rvalue references.

The above is the detailed content of Why does `std::forward` disable template argument deduction in Visual Studio 2010?. For more information, please follow other related articles on the PHP Chinese website!