rueisnom.com






  1. Native handle
  2. Native pathname format
  3. Nearest integer floating point operations
  4. Negative value if lhs appears before rhs in lexicographical order.
  5. Negative value if lhs is
  6. Negative value if s1 is
  7. Negative value if the first differing byte (reinterpreted as unsigned char) in lhs is less than the corresponding byte in rhs.
  8. Negative value if the value of the first differing wide character in lhs is less than the value of the corresponding wide character in rhs: lhs precedes rhs in lexicographical order.
  9. Nested allocator class
  10. Nested class declarations obey member access specifiers, a private member class cannot be named outside the scope of the enclosing class, although objects of that class may be manipulated:
  11. Nested classes
  12. Nested classes can be forward-declared and later defined, either within the same enclosing class body, or outside of it:
  13. Nested requirements
  14. Network is down
  15. Network unreachable
  16. New operators such as **, <>, or &| cannot be created.
  17. New-expressions are allowed to elide or combine allocations made through replaceable allocation functions. In case of elision, the storage may be provided by the compiler without making the call to an allocation function (this also permits optimizing out unused new-expression). In case of combining, the allocation made by a new-expression E1 may be extended to provide additional storage for another new-expression E2 if all of the following is true:
  18. Newer "Minimum standard", recommended by Park, Miller, and Stockmeyer in 1993.
  19. Newlines are kept, and it's unspecified whether non-newline whitespace sequences may be collapsed into single space characters.
  20. No STREAM resources
  21. No additional synchronization guarantees other than what's already provided by shared state.
  22. No bounds checking is performed: the behavior is undefined if pos >= size().
  23. No buffer space available
  24. No child processes
  25. No destructors for automatic objects are called. If replacing of std::longjmp with throw and setjmp with catch would execute a non-trivial destructor for any automatic object, the behavior of such std::longjmp is undefined.
  26. No elements are copied or moved, only the internal pointers of the container nodes are repointed. All pointers and references to the transferred elements remain valid, but now refer into *this, not into source.
  27. No elements are copied or moved, only the internal pointers of the container nodes are repointed. All pointers and references to the transferred elements remain valid, but now refer into *this, not into source. Iterators referring to the transferred elements and all iterators referring to *this are invalidated.
  28. No elements are copied or moved, only the internal pointers of the list nodes are re-pointed. The behavior is undefined if: get_allocator() != other.get_allocator(). No iterators or references become invalidated, the iterators to moved elements remain valid, but now refer into *this, not into other.
  29. No elements are copied. pos must be either a deferenceable valid iterator into *this or the before_begin() iterator (in particular, end() is not a valid argument for pos). The behavior is undefined if get_allocator() != other.get_allocator(). No iterators or references become invalidated, the iterators to the moved elements now refer into *this, not into other.
  30. No elements are copied. The container other becomes empty after the operation. The function does nothing if other refers to the same object as *this. If get_allocator() != other.get_allocator(), the behavior is undefined. No iterators or references become invalidated, except that the iterators of moved elements now refer into *this, not into other. The first version uses operator< to compare the elements, the second version uses the given comparison function comp.
  31. No error handling is provided.
  32. No exception guarantee
  33. No exception guarantees.
  34. No floating-point exceptions are raised.
  35. No implementation of denormalization loss mechanism exists (accuracy loss is detected after rounding, as inexact result), and this option was removed in the 2008 revision of IEEE Std 754.
  36. No implicit conversions are used. Multiplications and divisions are avoided where possible, if it is known at compile time that one or more parameters are 1. Computations are done in the widest type available and converted, as if by static_cast, to the result type only when finished.
  37. No input is consumed. Does not increment the assignment count. If the specifier has assignment-suppressing operator defined, the behavior is undefined.
  38. No iterators or references are invalidated.
  39. No iterators or references are invalidated. If the insertion is successful, pointers and references to the element obtained while it is held in the node handle are invalidated, and pointers and references obtained to that element before it was extracted become valid. (since C++17).
  40. No iterators or references except for back() and end() are invalidated.
  41. No locks are unlocked. If the *this held ownership of the associated mutex prior to the call, the caller is now responsible to unlock the mutex.
  42. No locks available
  43. No message is available on the STREAM head read queue
  44. No message of the desired type
  45. No objects of an abstract class can be created (except for base subobjects of a class derived from it) and no non-static data members of an abstract class can be declared.
  46. No operation on T may throw exceptions
  47. No operation on CharTraits may throw an exception.
  48. No operations on rdbuf are performed, it is not destroyed.
  49. No operations result in undefined behavior even if the result is not representable in the floating-point type. The floating-point environment in effect may be different from the calling thread's floating-point environment.
  50. No other guarantees are given: type_info objects referring to different types may have the same hash_code (although the standard recommends that implementations avoid this as much as possible), and hash_code for the same type can change between invocations of the same program.