HP aC++/HP ANSI C Release Notes (B3901-90037; A.06.26; September 2011)

C++0x relaxes that restriction to allow such names as an unevaluated operand, such as
sizeof(X::m), typeid(X::m), and decltype(X::m). With this release, aC++
now accepts this usage in C++0x mode and non-strict C++98/03 mode; such references
are transformed into a compiler-generated member-access expression using 0 cast to the
appropriate type as the object pointer.
As an extension, these references are also accepted as subexpressions of unevaluated
operands, such as sizeof(X::arr[0]), even in strict C++0x mode.
Defaulted and deleted functions
Deleted functions (= delete;) and defaulted special member functions (= default;)
are now supported.
A deleted function is a function declaration that cannot be referenced.
For example:
int f(int) = delete;
short f(short);
int x = f(3); // Error: selected function is deleted.
int y = f((short)3); // Okay.
Special member functions that can be implicitly defined can instead be explicitly declared,
but with a default definition. As the following example shows, the default definition can
be specified inside or outside the enclosing class definition, but only if it appears inside
the class can that class be a POD type (if all other constraints for POD types are fulfilled):
struct S { S(S const&) = default; };
struct T { T(T const&); };
T::T(T const&) = default;
In C++0x mode, auto is always a type specifier, not a storage-class specifier
The traditional meaning of auto as a storage class specifier is no longer enabled. auto
is therefore always a type specifier in C++0x mode. It is used for automatic type
deduction; when used in a declaration, it makes the type of the thing declared the same
as the type of whatever initialized it. For example:
typedef int T;
int x;
void f() {
auto T(x); // This is now the declaration of a variable T
// initialized with x (and hence of the same type as x).
// Previously, it was the declaration of a variable x of type T.
auto int y; // Now an error: Multiple type specifiers.}
Lambdas
Lambda functions are now supported.
A lambda expression is an anonymous function object containing a code snippet (for
example, predicate logic) that can be specified very succinctly by the programmer without
having to declare a function-local class; it is also referred to as closure because a lambda
New features in version A.06.25 17