HP aC++/HP C A.06.25 Release Notes

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
New Features in Version A.06.25 13