Thread: C++ Primer exercise 16.47

I'm a bit confused about type conversions in this exercise so I hope someone will enlighten me. C++ is a statically typed language therefore types must match otherwise conversion rules must be provided. This exercise illustrate how to preserve type informations using the function template std::forward, for better understanding I played with the code changing it to test different scenarios and simplifying I wrote this code:

Code:

#include <iostream>
#include <utility>

using namespace std;

template <typename F, typename T1, typename T2>
void flip(F f, T1 &&t1, T2 &&t2)
{
        // f(t2, t1);   // error: it calls g(int, int)
        f(forward<T2>(t2), forward<T2>(t1));
}

void g(int&& i, int&& j)        {cout << i << " " << j << endl; }

int main()
{
        int z(0);
        flip(g, 42, z);
        g(42,42);

        return EXIT_SUCCESS;
}

std::forward return a rvalue reference.
1) "&&i" isn't bound to "t2" (a lvalue) but to a rvalue reference of "z" therefore any further use of "z" value must be avoided.
2) "&&i" is bound to the rvalue reference of std::forward therefore any further use of "t2" must be avoided ("z" lvalue not moved). And the same applies to "t1"
Which of these two answers is correct?
Thank you in advance

Are those answers given in the book, or are they yours? Answer 1 is definitely wrong. You're passing z (an lvalue) as the argument for t2, which it then cannot take by rvalue reference, unlike the rvlaue 42 passed to t1.

I tried your example and it doesn't even compile here, because you only defined flip with rvalue references as parameters. So I don't think answer 2 is relevant in light of that road block.

You could use std::move on z, but I don't suppose that's the purpose of the exercise.

Yep! my mistakes (I played with the code too much) the definition of g function at line 13 has changed, then I correct the typo at line 10 (thanks Elysia) in second parameter of the function pointer f, T2 has changed to T1:

Code:

#include <iostream>
#include <utility>

using namespace std;

template <typename F, typename T1, typename T2>
void flip(F f, T1 &&t1, T2 &&t2)
{
        // f(t2, t1);   // error: it calls g(int, int)
        f(std::forward<T2>(t2), std::forward<T1>(t1));
}

void g(int&& i, int& j) {cout << i << " " << j << endl; }

int main()
{
        int z(0);
        flip(g, z, 42);

        return EXIT_SUCCESS;
}

Now it's all as the book illustrate, because of these changes I'll reformulate possible answers (@~Adrian: those are mine not from the book):
1) The first parameter of g function (&&i) isn't bound to "t2" (a lvalue) but to the rvalue literal "42". The second parameter of g function (&j) is bound to the rvalue reference of std::forward therefore any further use of "t1" must be avoided ("z" object untouched).
2) The first parameter of g function (&&i) isn't bound to "t2" (a lvalue) but to the rvalue literal "42". The second parameter of g function (&j) isn't bound to "t1" (although it can) but to "z" object therefore any further use of "t1" value is allowed.
Which one is it right?
Thank you again

The number 2 because &j is bound to z passed as lvalue via std::forward
Any further comments?

No, nothing to say it's clear now. Instead could I have confirmation about that std::forward act as std::move on t2?
t2 is bound to the literal 42 that is a rvalue therefore std::forward returning rvalues it behaves as std::move on t2 and any further access to t2's value inside flip is unsafe, am I right?
code:

Code:

template <typename F, typename T1, typename T2>
void flip(F f, T1 &&t1, T2 &&t2)
{
        // f(t2, t1);   // error: it calls g(int, int)
        f(std::forward<T2>(t2), std::forward<T1>(t1));
        int val = t2;   // <------ wrong? 
}

Originally Posted by Elysia

&& when used as template parameters aren't rvalue references, they're known as universal references (now called forwarding references, I think?). They're different because they can bind both rvalue and lvalue references.

Thanks for the insight Elysia. I don't want to hijack this thread, but could you elaborate on what you meant with:

Originally Posted by Elysia

(Perhaps confusingly enough, if you pass an rvalue directly, it actually becomes an lvalue, which is why the first g call fails.)

Do you mean that t1 and t2 are lvalues no matter what's passed to flip, or is this about something else?