Re: how do you write proxies for rvalues?
On 17 Aug., 09:56, Gene Bushuyev wrote:
As an exercise to familiarize myself with rvalues I decided to write a
proxy class for plus operator. It turned out to be more difficult than
I thought.
Could you explain the purpose of your class template? Specifically, do
you really intent to store references to lvalue arguments in your
PlusProxy class?
Here is what I got (tell me if I did it wrong):
template<class T1, class T2>
class PlusProxy
{
T1 t1;
T2 t2;
public:
PlusProxy(T1&& t1, T2&& t2)
: t1(std::forward<T1>(t1)),
t2(std::forward<T1>(t2))
{}
PlusProxy(PlusProxy&& other)
: t1(std::forward<T1>(other.t1)),
t2(std::forward<T1>(other.t2))
{}
PlusProxy&& operator = (PlusProxy&& other)
{
swap(std::forward<T1>(*this), other);
}
That can't be right. T1 is the wrong type here and you forgot a return
statement. The rvalue reference as return type seems fishy. It's
definitely unusual (and probably wrong depending on your goals).
friend
void swap(PlusProxy<T1,T2>&& p1, PlusProxy<T1,T2>&& p2)
{
swap(std::forward<T1>(p1.t1), std::forward<T1>(p2.t1));
swap(std::forward<T1>(p1.t2), std::forward<T1>(p2.t2));
}
Do you realize that this function only accepts rvalues and not lvalues
(since the reference binding rules update from almost two years ago)?
decltype(typename std::remove_reference<T1>::type() +
typename std::remove_reference<T2>::type())
operator ()() const { return t1 + t2; }
//decltype(typename std::remove_reference<T1>::type()[0] +
// typename std::remove_reference<T2>::type()[0])
//operator [](std::size_t i) const { return t1[i] + t2[i]; }
};
template<class T1, class T2>
PlusProxy<T1, T2> MakePlus (T1&& t1, T2&& t2)
{
return PlusProxy<T1,T2>(std::forward<T1>(t1),
std::forward<T2>(t2));
}
int main()
{
int a = 1, b = 2;
std::cout << "int 1: " << MakePlus(a, b)() << std::endl;
Is it intentional that MakePlus returns a PlusProxy<int&,int&> object
in this case? Apparently, the proxy object stores a reference if the
argument to MakePlus was an lvalue and it stores the object directly
if the argument was an rvalue. Just saying because there is a slim
chance that this was unintentional.
I compiled this example with VC2010 and gcc 4.5 and got the same
results.
The first problem I encountered was with operator[] in this example.
It turns out if I try to instantiate PlusProxy on int type, compiler
would complain about decltype(...) for operator[]. Why? There is no
instantiation of operator[], why doesn't compiler defer this check to
the point of instantiation as it would be the case if I used return
type without decltype.
This is just a guess: Since you use the operator as part of the
function's signature (decltype for return type) and the function is
not a template member, the compiler probably tries to at least figure
out what kind of function that is (what return type it has) by
evaluating the decltype expression. Hence, the error.
The second problem was with instantiation on string types. The
expression MakePlus(s1, "world") wouldn't compile because
remove_reference did something to the string literal in decltype
expression, so I'm getting this error:
conversion from 'int' to non-scalar type 'const char [6]' requested.
Is there anything I can do to handle both string and non-string
literals in the same way?
decltype(typename std::remove_reference<T1>::type() +
typename std::remove_reference<T2>::type())
operator ()() const { return t1 + t2; }
It probably makes sense to write a typedef for this and use a helper
function like declval:
typedef decltype( declval<T1&>() + declval<T2&> ) result_type;
I'm exploiting reference collapsing and using lvalue references here
because 't1' and 't2' in your return expression are lvalues but T1 and
T2 might be object types in which case declval<T1>() would be an
rvalue. This is just to match exactly your return expression.
The declval template might not yet be part of your compiler's standard
library implementation. It looks approximately like this:
template<class T>
typename std::add_rvalue_reference<T> declval();
It's only supposed to be used in unevaluated contexts like decltype
which is why we don't need a definition for it.
Cheers!
SG
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]