Re: how do you write proxies for rvalues?
On 17 Aug., 09:56, Gene Bushuyev <publicfil...@gbresearch.com> 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.
Here is what I got (tell me if I did it wrong):
In the following I assume that at least the headers <string>,
<iostream>, <utility>, and <type_traits> are included.
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);
}
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));
}
Note that above operator= implementation will never consider
your above free swap function. This is so, because operator=
provides lvalues to swap, but your swap acts only on rvalues.
Either replace your above free swap by
friend void swap(PlusProxy<T1,T2>& p1, PlusProxy<T1,T2>& p2);
or add such an overload to enable proper swapping.
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;
std::cout << "int 2: " << MakePlus(a, 1)() << std::endl;
std::cout << "int 3: " << MakePlus(5, 2)() << std::endl;
std::string s1("-string1-");
std::string s2("-string2-");
std::cout << "str 1: " << MakePlus(s1, s2)() << std::endl;
std::cout << "str 2: "
<< MakePlus(s1, std::string("hello"))() << std::endl;
//std::cout << "str 3: "
// << MakePlus(s1, "world")() << std::endl;
//std::cout << "str 4: "
// << MakePlus("hello", "world")() << std::endl;
}
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.
If a specialization of PlusProxy is instantiated, this will cause the
instantiation of all member *declarations*. But your last two member
declaration of operator ()() and operator[] can be ill-formed
depending
on the type.
To solve this problem, you need to make them constrained members.
This is possible in C++0x by taking advantage of default template
arguments in function templates. E.g. change
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]; }
to
template<class U = T1, class V = T2>
decltype(typename std::remove_reference<U>::type()[0] +
typename std::remove_reference<V>::type()[0])
operator [](std::size_t i) const { return t1[i] + t2[i]; }
and similarly for your operator() overload.
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?
Using std::remove_reference is a bad idea. In fact, you use it
as a work-around for a proper solution, which should use
std::declval. Given this tool, the recommended declarations
of both members could be
template<class U = T1, class V = T2>
decltype(std::declval<U>() + std::declval<V>())
operator ()() const { return t1 + t2; }
template<class U = T1, class V = T2>
decltype(std::declval<U>()[std::declval<std::size_t>()] +
std::declval<V>()[std::declval<std::size_t>()])
operator [](std::size_t i) const { return t1[i] + t2[i]; }
HTH & Greetings from Bremen,
Daniel Kr?gler
--
[ See http://www.gotw.ca/resources/clcm.htm for info about ]
[ comp.lang.c++.moderated. First time posters: Do this! ]