Re: What's the summary of N2855 - Rvalue References and Exception Safety?

On 2 Mai, 14:58, DeMarcus wrote:


N2855 is superseeded by N2983 and N3050.

http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2010/n3050.html

I think N3050 as been accepted. At least the FCD (N3092) seems to
include the proposed changes of N3050.


As far as I can tell, it's a good idea to avoid classes with throwing
move constructors. But a throwing move constructor is not that big an
issue as it used to be. The standard library will offer a "conditional
move" via std::move_if_noexcept which allows you to fall back on a
copy construction in cases where exception-safety is an issue. The
general idea is to allow throwing move constructors (for performance
reasons) but have it detectable so you can decide on a case by case
basis what's best.

One thing you should definitely avoid is a class which is nothrow_
move_constructible but has a throwing move assignment operator. This
is because std::move_if_noexcept only considers move construction and
not move assignment.

A more general solution to move_if_noexcept might be

  move_if<noexcept( /expr1/ )>( /expr2/ )

Here, the noexcept operator is used to query the compiler whether
expr1 might throw an exception. It results in a boolean constant which
is used as template parameter. move_if could be defined like this:

  template<bool Condition, typename T>
  typename conditional<Condition,T&&,T const&>::type
  move_if(T& x)
  { return std::move(x); }

(This is not part of the FCD, just an idea, if you're not happy with
std::move_if_noexcept only considering move construction.)


Given N3050 and N3053 ("Defining Move Special Member Functions"), I
think the best thing to do is to avoid having to write custom copy/
move constructors/assignment operators and destructors. If you write a
simple class that just aggregates a couple of objects like this:

 class matrix {
   int m, n;
   std::vector<double> coefficients;
 public:
   matrix() : m(0), n(0) {}
   matrix(int m, int n) : m(m), n(n), coefficients(m*n) {}
   ...
 };

(with no custom copy/move constructors/assignment operators and
destructor) the compiler will automatically generate all necessary
functions that do the "right thing" including move special member
functions. Ideally the compiler decorates the move functions with the
appropriate noexcept exception specification automatically (in the
spirit of N3050) but I havn't found anything to that effect in the FCD
(section 12.8) just now.

Of course, you cannot get away with this every time. Implementers of
std::vector have to provide custom copy and move operations as well as
a destructor. But as long as you don't have to, you shouldn't IMHO.

Cheers,
SG

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