For an object with static storage duration constructed after a function is registered with atexit, then following the call to exit, the registered function is not called until the execution of the object’s destructor has completed.

hndl&&hndl->is_open()

struct i
{
virtual void f( int ){}
};

struct j : public i
{
  void f( long ){} //oops
};

P>А ктото собирается делать atomic storage duration ? Вон exception handling прописан и у всех отговорки что деление на 0 несинхронное и типа не обязательное. Для этого поддержка со стороны ос нужна, если не железа . Да и проку мало от hndl&&hndl->is_open() Нужно боле крупные кески лочить, а не один оператор до ;

bool watcher_t::is_connected() const
{
    return hndl&&hndl->is_open();
}

Deleted as redundant with descriptions of operators (original text from p17):
(*зачёркнуто*)
In the evaluation of each of the expressions

a && b
a || b
a ? b : c
a , b
using the built-in meaning of the operators in these expressions (5.14, 5.15, 5.16, 5.18), there is a sequence point after the evaluation of the first expression. [ Footnote: The operators indicated in this paragraph are the built-in operators, as described in clause 5. When one of these operators is overloaded (clause 13) in a valid context, thus designating a user-defined operator function, the expression designates a function invocation, and the operands form an argument list, without an implied sequence point between them. —end footnote ]
(*зачёркнуто*)

ШЕ>Deleted as redundant with descriptions of operators (original text from p17):
ШЕ>(*зачёркнуто*)

ШЕ>hndl&&hndl->is_open()
ШЕ>

wait_io_complete() && *buffer

if()
if()
{
}

ШЕ>hndl&&hndl->is_open()
ШЕ>

ШЕ>Или я что-то не так понял

5.14p2 (logical AND operator), and also 5.15p2 (logical OR operator):

The result is a bool. If the second expression is evaluated, every value computation and side effect associated with the first expression is sequenced before every value computation and side effect associated with the second expression.

The && operator groups left-to-right. The operands are both implicitly converted to type bool (clause 4).
The result is true if both operands are true and false otherwise. Unlike &, && guarantees left-to-right
evaluation: the second operand is not evaluated if the first operand is false.