Re: Rvalue-references, binding and conversions

From:

James Hopkin <tasjaevan@gmail.com>

Newsgroups:

comp.lang.c++.moderated

Date:

Fri, 5 Dec 2008 20:34:33 CST

Message-ID:

<f6225b02-4423-4a87-9fd4-0fade72cab63@j35g2000yqh.googlegroups.com>

On Dec 5, 1:18 am, SG <s.gesem...@gmail.com> wrote:

I appreciate the existence of rvalue references but IMHO their should
be limited to exactly what they were designed for: move semantics and
perfect forwarding.

There are also many cases where binding a reference to a temporary is
useful, such as

ofstream("pootle.txt") << "flump";

While testing with concepts and rvalue references
I came across this problem:

    concept VectorExpression<typename T> {};

    struct foobar {};

    concept_map VectorExpression<foobar> {};

    template<VectorExpression VE>
    void do_something(const VE &); // #1

    template<VectorExpression VE>
    void do_something(VE &&); // #2

    foobar func1();
    foobar& func2();

int main() {
    do_something(func1()); // #1 (right?)
    do_something(func2()); // #1 or #2 with VE = foobar&

}

Template parameter deduction rules try to make VE=foobar& in the 2nd
case but foobar& is not a model of the concept VectorExpression. Bam!

So, to make this work like intended we have to use a trick like CRTP
to suppress top-level template parameter deduction and hence avoid the
rule that makes perfect forwarding possible. I'm not too happy about
it.

That looks wrong. The func1() line should call #2, surely?

The func2() line should call #1 (lvalues prefering lvalue reference
overloads), in which case the template parameter is deduced as foobar.

Does a concept_map for foobar also apply to foobar&? If not,
constrained forwarding would break.

   template <VectorExpression T>
   void forward_vector(T&&);

   void test()
   {
     forward_vector(func2()); // T deduced as foobar&
   }

James

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]