Re: [boost] [parameter] Tutorial checked in

From: David Abrahams (dave_at_[hidden])
Date: 2005-07-22 10:33:11

Rob Stewart <stewart_at_[hidden]> writes:

> From: David Abrahams <dave_at_[hidden]>
>> Rob Stewart <stewart_at_[hidden]> writes:
>> > From: David Abrahams <dave_at_[hidden]>
>> >
>> >    On the other hand\x{2014}as you may recall from the parameter
>> >    table\x{2014}``color_map`` is an \x{201C}out\x{201D}
>> >    parameter, so it really should be passed by non-const
>> >    reference.
>> >
>> > Note that "color_map" and "out" are quoted significantly
>> > differently with no apparent reason.
>> 
>> No, ``color_map`` isn't quotation; it's markup for "code font."  Look
>> at the HTML.
>
> I was looking at it in the browser.  I saw "``color_map``" and
> "<fancy open quote>out<fancy close quote>" so I saw no "code
> font" markup.  Unless I'm misunderstanding you, something is
> wrong.

Thanks, I just fixed it.

>> >    A keyword object has a pair of operator= overloads that ensure
>> >    we can pass anything by name, but when an \x{201C}out\x{201D}
>> >    parameter is passed positionally, that's no help: in this
>> >    case, core::depth_first_search would end up with a const
>> >    reference to the color_map and compilation will fail when
>> >    mutating operations are used on it.
>> >
>> > That's a long sentence and did you really mean to say "we can
>> > pass *anything*" (emphasis mine)?
>> 
>> Yep.
>
> I didn't look, but it sounded odd that one could pass an int,
> char *, std::complex, etc.

Well, you can at least pass anything to the keyword's operator=.
Whether or not the depth_first_search function compiles is another
matter.

>> > Perhaps this would be better:
>> >
>> >    A keyword object has a pair of operator = overloads that
>> >    ensure we can pass references to const or non-const objects by
>> >    name, 
>> 
>> You don't get to pass references to anything in C++.  You pass the
>> object referred to by a name or expression and the callee decides
>> whether it goes by reference.
>
> Yeah, I misspoke (miswrote?).  I was referring to the parameter
> type when I should have been discussing the allowable argument
> types.
>
>> Also, the point is that you can pass both lvalues and rvalues, or
>> temporaries and non-temporaries, not that the objects can be const or
>> non-const.  You can do that just fine with a single templated function
>> taking a T& (T will be deduced as U const when the object is constant).
>
> Pedantry aside, that's not the same as *anything*.

Pedantry aside, what else is there?

>> >    but when an "out" parameter is passed positionally,
>> >    that's no help.  In that case, core:;depth_first_search would
>> >    end up with a...."
>
> What about splitting the sentence into two?

How's this?

  A keyword object has a pair of ``operator=`` overloads that ensure
  we can pass anything—temporary or not, ``const`` or not—by name,
  while preserving the mutability of non-temporaries:

  .. parsed-literal::

    template <class A>                  // handles non-const, 
    |ArgumentPack| operator=(A&);       // non-temporary objects

    template <class A>                  // handles const objects
    |ArgumentPack| operator=(A const&); // and temporaries

  However, when an “out” parameter is passed positionally, there's no
  keyword object involved.  With our ``depth_first_search`` overload
  set above, the ``color_map`` will be passed by ``const`` reference,
  and compilation will fail when mutating operations are used on it.
  The simple solution is to add another overload that takes a
  non-``const`` reference in the position of the “out” parameter:

-- 
Dave Abrahams
Boost Consulting
www.boost-consulting.com