| 
    Checker
    | 
    Guideline
    | 
|---|
   | C++0014 | DCL52-CPP. Never qualify a reference type with const or volatile | 
  
   | C++1067 | DCL60-CPP. Obey the one-definition rule | 
  
   | C++1109 | DCL53-CPP. Do not write syntactically ambiguous declarations | 
  
   | C++1509 | DCL60-CPP. Obey the one-definition rule | 
  
   | C++1510 | DCL60-CPP. Obey the one-definition rule | 
  
   | C++1552 | DCL56-CPP. Avoid cycles during initialization of static objects | 
  
   | C++1554 | DCL56-CPP. Avoid cycles during initialization of static objects | 
  
   | C++1704 | DCL56-CPP. Avoid cycles during initialization of static objects | 
  
   | C++1772 | CON53-CPP. Avoid deadlock by locking in a predefined order | 
  
   | C++1773 | CON53-CPP. Avoid deadlock by locking in a predefined order | 
  
   | C++1774 | CON52-CPP. Prevent data races when accessing bit-fields from multiple threads | 
  
   | C++1775 | CON52-CPP. Prevent data races when accessing bit-fields from multiple threads | 
  
   | C++1778 | CON55-CPP. Preserve thread safety and liveness when using condition variables | 
  
   | C++1779 | CON55-CPP. Preserve thread safety and liveness when using condition variables | 
  
   | C++2012 | DCL50-CPP. Do not define a C-style variadic function | 
  
   | C++2045 | DCL57-CPP. Do not let exceptions escape from destructors or deallocation functions | 
  
   | C++2047 | DCL57-CPP. Do not let exceptions escape from destructors or deallocation functions | 
  
   | C++2110 | MEM51-CPP. Properly deallocate dynamically allocated resources | 
  
   | C++2111 | MEM51-CPP. Properly deallocate dynamically allocated resources | 
  
   | C++2112 | MEM51-CPP. Properly deallocate dynamically allocated resources | 
  
   | C++2113 | MEM51-CPP. Properly deallocate dynamically allocated resources | 
  
   | C++2118 | MEM51-CPP. Properly deallocate dynamically allocated resources | 
  
   | C++2160 | DCL54-CPP. Overload allocation and deallocation functions as a pair in the same scope | 
  
   | C++2510 | DCL53-CPP. Do not write syntactically ambiguous declarations | 
  
   | C++2518 | DCL59-CPP. Do not define an unnamed namespace in a header file | 
  
   | C++2625 | DCL50-CPP. Do not define a C-style variadic function | 
  
   | C++2888 | MSC54-CPP. A signal handler must be a plain old function | 
  
   | C++3013 | INT50-CPP. Do not cast to an out-of-range enumeration value | 
  
   | C++3033 | EXP56-CPP. Do not call a function with a mismatched language linkage | 
  
   | C++3038 | EXP56-CPP. Do not call a function with a mismatched language linkage | 
  
   | C++3066 | EXP55-CPP. Do not access a cv-qualified object through a cv-unqualified type | 
  
   | C++3072 | OOP51-CPP. Do not slice derived objects | 
  
   | C++3073 | CTR56-CPP. Do not use pointer arithmetic on polymorphic objects | 
  
   | C++3112 | EXP57-CPP. Do not cast or delete pointers to incomplete classes | 
  
   | C++3119 | MEM54-CPP. Provide placement new with properly aligned pointers to sufficient storage capacity | 
  
   | C++3128 | MEM54-CPP. Provide placement new with properly aligned pointers to sufficient storage capacity | 
  
   | C++3129 | MEM57-CPP. Avoid using default operator new for over-aligned types | 
  
   | C++3139 | CTR50-CPP. Guarantee that container indices and iterators are within the valid range | 
  
   | C++3140 | CTR50-CPP. Guarantee that container indices and iterators are within the valid range | 
  
   | C++3161 | ERR62-CPP. Detect errors when converting a string to a number | 
  
   | C++3162 | STR53-CPP. Range check element access | 
  
   | C++3163 | STR53-CPP. Range check element access | 
  
   | C++3164 | STR53-CPP. Range check element access | 
  
   | C++3165 | STR53-CPP. Range check element access | 
  
   | C++3166 | EXP51-CPP. Do not delete an array through a pointer of the incorrect type | 
  
   | C++3180 | DCL58-CPP. Do not modify the standard namespaces | 
  
   | C++3181 | DCL58-CPP. Do not modify the standard namespaces | 
  
   | C++3182 | DCL58-CPP. Do not modify the standard namespaces | 
  
   | C++3220 | EXP50-CPP. Do not depend on the order of evaluation for side effects | 
  
   | C++3221 | EXP50-CPP. Do not depend on the order of evaluation for side effects | 
  
   | C++3222 | EXP50-CPP. Do not depend on the order of evaluation for side effects | 
  
   | C++3223 | EXP50-CPP. Do not depend on the order of evaluation for side effects | 
  
   | C++3225 | CTR58-CPP. Predicate function objects should not be mutable | 
  
   | C++3225 | MEM52-CPP. Detect and handle memory allocation errors | 
  
   | C++3226 | CTR58-CPP. Predicate function objects should not be mutable | 
  
   | C++3226 | MEM52-CPP. Detect and handle memory allocation errors | 
  
   | C++3227 | CTR58-CPP. Predicate function objects should not be mutable | 
  
   | C++3227 | MEM52-CPP. Detect and handle memory allocation errors | 
  
   | C++3228 | EXP50-CPP. Do not depend on the order of evaluation for side effects | 
  
   | C++3228 | CTR58-CPP. Predicate function objects should not be mutable | 
  
   | C++3228 | MEM52-CPP. Detect and handle memory allocation errors | 
  
   | C++3229 | CTR58-CPP. Predicate function objects should not be mutable | 
  
   | C++3229 | MEM52-CPP. Detect and handle memory allocation errors | 
  
   | C++3230 | CTR58-CPP. Predicate function objects should not be mutable | 
  
   | C++3231 | CTR58-CPP. Predicate function objects should not be mutable | 
  
   | C++3232 | CTR58-CPP. Predicate function objects should not be mutable | 
  
   | C++3233 | CTR58-CPP. Predicate function objects should not be mutable | 
  
   | C++3234 | CTR58-CPP. Predicate function objects should not be mutable | 
  
   | C++3240 | EXP52-CPP. Do not rely on side effects in unevaluated operands | 
  
   | C++3241 | EXP52-CPP. Do not rely on side effects in unevaluated operands | 
  
   | C++3293 | CTR57-CPP. Provide a valid ordering predicate | 
  
   | C++3337 | MEM51-CPP. Properly deallocate dynamically allocated resources | 
  
   | C++3339 | MEM51-CPP. Properly deallocate dynamically allocated resources | 
  
   | C++3402 | OOP52-CPP. Do not delete a polymorphic object without a virtual destructor | 
  
   | C++3403 | OOP52-CPP. Do not delete a polymorphic object without a virtual destructor | 
  
   | C++3404 | OOP52-CPP. Do not delete a polymorphic object without a virtual destructor | 
  
   | C++3508 | ERR60-CPP. Exception objects must be nothrow copy constructible | 
  
   | C++3510 | ERR53-CPP. Do not reference base classes or class data members in a constructor or destructor function-try-block handler | 
  
   | C++3802 | CTR53-CPP. Use valid iterator ranges | 
  
   | C++3809 | ERR59-CPP. Do not throw an exception across execution boundaries | 
  
   | C++3810 | ERR59-CPP. Do not throw an exception across execution boundaries | 
  
   | C++3852 | EXP58-CPP. Pass an object of the correct type to va_start | 
  
   | C++3853 | EXP58-CPP. Pass an object of the correct type to va_start | 
  
   | C++3915 | EXP59-CPP. Use offsetof() on valid types and members | 
  
   | C++3916 | EXP59-CPP. Use offsetof() on valid types and members | 
  
   | C++4003 | EXP54-CPP. Do not access an object outside of its lifetime | 
  
   | C++4026 | EXP54-CPP. Do not access an object outside of its lifetime | 
  
   | C++4030 | ERR54-CPP. Catch handlers should order their parameter types from most derived to least derived | 
  
   | C++4031 | ERR61-CPP. Catch exceptions by lvalue reference | 
  
   | C++4032 | DCL57-CPP. Do not let exceptions escape from destructors or deallocation functions | 
  
   | C++4035 | ERR51-CPP. Handle all exceptions | 
  
   | C++4035 | ERR55-CPP. Honor exception specifications | 
  
   | C++4036 | ERR51-CPP. Handle all exceptions | 
  
   | C++4036 | ERR55-CPP. Honor exception specifications | 
  
   | C++4037 | ERR51-CPP. Handle all exceptions | 
  
   | C++4053 | OOP53-CPP. Write constructor member initializers in the canonical order | 
  
   | C++4072 | OOP54-CPP. Gracefully handle self-copy assignment | 
  
   | C++4073 | OOP54-CPP. Gracefully handle self-copy assignment | 
  
   | C++4075 | ERR56-CPP. Guarantee exception safety | 
  
   | C++4075 | OOP54-CPP. Gracefully handle self-copy assignment | 
  
   | C++4075 | OOP58-CPP. Copy operations must not mutate the source object | 
  
   | C++4076 | ERR56-CPP. Guarantee exception safety | 
  
   | C++4076 | OOP54-CPP. Gracefully handle self-copy assignment | 
  
   | C++4260 | OOP50-CPP. Do not invoke virtual functions from constructors or destructors | 
  
   | C++4261 | OOP50-CPP. Do not invoke virtual functions from constructors or destructors | 
  
   | C++4262 | MEM51-CPP. Properly deallocate dynamically allocated resources | 
  
   | C++4263 | MEM51-CPP. Properly deallocate dynamically allocated resources | 
  
   | C++4264 | MEM51-CPP. Properly deallocate dynamically allocated resources | 
  
   | C++4273 | OOP50-CPP. Do not invoke virtual functions from constructors or destructors | 
  
   | C++4274 | OOP50-CPP. Do not invoke virtual functions from constructors or destructors | 
  
   | C++4275 | OOP50-CPP. Do not invoke virtual functions from constructors or destructors | 
  
   | C++4276 | OOP50-CPP. Do not invoke virtual functions from constructors or destructors | 
  
   | C++4277 | OOP50-CPP. Do not invoke virtual functions from constructors or destructors | 
  
   | C++4278 | OOP50-CPP. Do not invoke virtual functions from constructors or destructors | 
  
   | C++4279 | OOP50-CPP. Do not invoke virtual functions from constructors or destructors | 
  
   | C++4280 | OOP50-CPP. Do not invoke virtual functions from constructors or destructors | 
  
   | C++4281 | OOP50-CPP. Do not invoke virtual functions from constructors or destructors | 
  
   | C++4282 | OOP50-CPP. Do not invoke virtual functions from constructors or destructors | 
  
   | C++4303 | MEM50-CPP. Do not access freed memory | 
  
   | C++4304 | MEM50-CPP. Do not access freed memory | 
  
   | C++4631 | DCL57-CPP. Do not let exceptions escape from destructors or deallocation functions | 
  
   | C++4632 | MEM52-CPP. Detect and handle memory allocation errors | 
  
   | C++4632 | ERR55-CPP. Honor exception specifications | 
  
   | C++4634 | ERR58-CPP. Handle all exceptions thrown before main() begins executing | 
  
   | C++4636 | ERR58-CPP. Handle all exceptions thrown before main() begins executing | 
  
   | C++4637 | ERR58-CPP. Handle all exceptions thrown before main() begins executing | 
  
   | C++4639 | ERR54-CPP. Catch handlers should order their parameter types from most derived to least derived | 
  
   | C++4639 | ERR58-CPP. Handle all exceptions thrown before main() begins executing | 
  
   | C++4671 | EXP55-CPP. Do not access a cv-qualified object through a cv-unqualified type | 
  
   | C++4986 | CON56-CPP. Do not speculatively lock a non-recursive mutex that is already owned by the calling thread | 
  
   | C++4987 | CON56-CPP. Do not speculatively lock a non-recursive mutex that is already owned by the calling thread | 
  
   | C++5003 | DCL51-CPP. Do not declare or define a reserved identifier | 
  
   | C++5014 | ERR50-CPP. Do not abruptly terminate the program | 
  
   | C++5015 | ERR52-CPP. Do not use setjmp() or longjmp() | 
  
   | C++5017 | OOP57-CPP. Prefer special member functions and overloaded operators to C Standard Library functions | 
  
   | C++5018 | CON51-CPP. Ensure actively held locks are released on exceptional conditions | 
  
   | C++5019 | CON54-CPP. Wrap functions that can spuriously wake up in a loop | 
  
   | C++5028 | MSC50-CPP. Do not use std::rand() for generating pseudorandom numbers | 
  
   | C++5038 | OOP57-CPP. Prefer special member functions and overloaded operators to C Standard Library functions | 
  
   | C++5041 | MSC51-CPP. Ensure your random number generator is properly seeded | 
  
   | C++5216 | STR50-CPP. Guarantee that storage for strings has sufficient space for character data and the null terminator | 
  
   | DF726 | EXP53-CPP. Do not read uninitialized memory | 
  
   | DF961 | CON50-CPP. Do not destroy a mutex while it is locked | 
  
   | DF978 | EXP53-CPP. Do not read uninitialized memory | 
  
   | DF2668 | CTR54-CPP. Do not subtract iterators that do not refer to the same container | 
  
   | DF2727 | EXP53-CPP. Do not read uninitialized memory | 
  
   | DF2728 | EXP53-CPP. Do not read uninitialized memory | 
  
   | DF2761 | CTR54-CPP. Do not subtract iterators that do not refer to the same container | 
  
   | DF2762 | CTR54-CPP. Do not subtract iterators that do not refer to the same container | 
  
   | DF2763 | CTR54-CPP. Do not subtract iterators that do not refer to the same container | 
  
   | DF2766 | CTR54-CPP. Do not subtract iterators that do not refer to the same container | 
  
   | DF2767 | CTR54-CPP. Do not subtract iterators that do not refer to the same container | 
  
   | DF2768 | CTR54-CPP. Do not subtract iterators that do not refer to the same container | 
  
   | DF2810 | OOP55-CPP. Do not use pointer-to-member operators to access nonexistent members | 
  
   | DF2811 | OOP55-CPP. Do not use pointer-to-member operators to access nonexistent members | 
  
   | DF2812 | EXP54-CPP. Do not access an object outside of its lifetime | 
  
   | DF2812 | OOP55-CPP. Do not use pointer-to-member operators to access nonexistent members | 
  
   | DF2813 | EXP54-CPP. Do not access an object outside of its lifetime | 
  
   | DF2813 | OOP55-CPP. Do not use pointer-to-member operators to access nonexistent members | 
  
   | DF2814 | EXP54-CPP. Do not access an object outside of its lifetime | 
  
   | DF2814 | OOP55-CPP. Do not use pointer-to-member operators to access nonexistent members | 
  
   | DF2835 | STR50-CPP. Guarantee that storage for strings has sufficient space for character data and the null terminator | 
  
   | DF2836 | STR50-CPP. Guarantee that storage for strings has sufficient space for character data and the null terminator | 
  
   | DF2839 | STR50-CPP. Guarantee that storage for strings has sufficient space for character data and the null terminator | 
  
   | DF2886 | MSC53-CPP. Do not return from a function declared [[noreturn]] | 
  
   | DF2888 | MSC52-CPP. Value-returning functions must return a value from all exit paths | 
  
   | DF2891 | CTR50-CPP. Guarantee that container indices and iterators are within the valid range | 
  
   | DF2930 | EXP54-CPP. Do not access an object outside of its lifetime | 
  
   | DF2931 | EXP54-CPP. Do not access an object outside of its lifetime | 
  
   | DF2932 | EXP54-CPP. Do not access an object outside of its lifetime | 
  
   | DF2933 | EXP54-CPP. Do not access an object outside of its lifetime | 
  
   | DF2934 | EXP54-CPP. Do not access an object outside of its lifetime | 
  
   | DF2961 | EXP53-CPP. Do not read uninitialized memory | 
  
   | DF2962 | EXP53-CPP. Do not read uninitialized memory | 
  
   | DF2963 | EXP53-CPP. Do not read uninitialized memory | 
  
   | DF2966 | EXP53-CPP. Do not read uninitialized memory | 
  
   | DF2967 | EXP53-CPP. Do not read uninitialized memory | 
  
   | DF2968 | EXP53-CPP. Do not read uninitialized memory | 
  
   | DF2971 | EXP53-CPP. Do not read uninitialized memory | 
  
   | DF2972 | EXP53-CPP. Do not read uninitialized memory | 
  
   | DF2973 | EXP53-CPP. Do not read uninitialized memory | 
  
   | DF2976 | EXP53-CPP. Do not read uninitialized memory | 
  
   | DF2977 | EXP53-CPP. Do not read uninitialized memory | 
  
   | DF3520 | MEM54-CPP. Provide placement new with properly aligned pointers to sufficient storage capacity | 
  
   | DF3521 | MEM54-CPP. Provide placement new with properly aligned pointers to sufficient storage capacity | 
  
   | DF3522 | MEM54-CPP. Provide placement new with properly aligned pointers to sufficient storage capacity | 
  
   | DF3523 | MEM54-CPP. Provide placement new with properly aligned pointers to sufficient storage capacity | 
  
   | DF3526 | CTR52-CPP. Guarantee that library functions do not overflow | 
  
   | DF3526 | CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow | 
  
   | DF3527 | CTR52-CPP. Guarantee that library functions do not overflow | 
  
   | DF3527 | CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow | 
  
   | DF3528 | CTR52-CPP. Guarantee that library functions do not overflow | 
  
   | DF3528 | CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow | 
  
   | DF3529 | CTR52-CPP. Guarantee that library functions do not overflow | 
  
   | DF3529 | CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow | 
  
   | DF3530 | CTR52-CPP. Guarantee that library functions do not overflow | 
  
   | DF3530 | CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow | 
  
   | DF3531 | CTR52-CPP. Guarantee that library functions do not overflow | 
  
   | DF3531 | CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow | 
  
   | DF3532 | CTR52-CPP. Guarantee that library functions do not overflow | 
  
   | DF3532 | CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow | 
  
   | DF3533 | CTR52-CPP. Guarantee that library functions do not overflow | 
  
   | DF3533 | CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow | 
  
   | DF3534 | CTR52-CPP. Guarantee that library functions do not overflow | 
  
   | DF3534 | CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow | 
  
   | DF4701 | EXP63-CPP. Do not rely on the value of a moved-from object | 
  
   | DF4702 | EXP63-CPP. Do not rely on the value of a moved-from object | 
  
   | DF4703 | EXP63-CPP. Do not rely on the value of a moved-from object | 
  
   | DF4706 | EXP61-CPP. A lambda object must not outlive any of its reference captured objects | 
  
   | DF4707 | EXP61-CPP. A lambda object must not outlive any of its reference captured objects | 
  
   | DF4708 | EXP61-CPP. A lambda object must not outlive any of its reference captured objects | 
  
   | DF4711 | FIO50-CPP. Do not alternately input and output from a file stream without an intervening positioning call | 
  
   | DF4712 | FIO50-CPP. Do not alternately input and output from a file stream without an intervening positioning call | 
  
   | DF4713 | FIO50-CPP. Do not alternately input and output from a file stream without an intervening positioning call | 
  
   | DF4721 | MEM56-CPP. Do not store an already-owned pointer value in an unrelated smart pointer | 
  
   | DF4722 | MEM56-CPP. Do not store an already-owned pointer value in an unrelated smart pointer | 
  
   | DF4723 | MEM56-CPP. Do not store an already-owned pointer value in an unrelated smart pointer | 
  
   | DF4726 | EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation | 
  
   | DF4727 | EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation | 
  
   | DF4728 | EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation | 
  
   | DF4729 | EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation | 
  
   | DF4731 | EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation | 
  
   | DF4732 | EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation | 
  
   | DF4733 | EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation | 
  
   | DF4734 | EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation | 
  
   | DF4736 | MEM55-CPP. Honor replacement dynamic storage management requirements | 
  
   | DF4737 | MEM55-CPP. Honor replacement dynamic storage management requirements | 
  
   | DF4738 | MEM55-CPP. Honor replacement dynamic storage management requirements | 
  
   | DF4739 | MEM55-CPP. Honor replacement dynamic storage management requirements | 
  
   | DF4741 | EXP60-CPP. Do not pass a nonstandard-layout type object across execution boundaries | 
  
   | DF4742 | EXP60-CPP. Do not pass a nonstandard-layout type object across execution boundaries | 
  
   | DF4743 | EXP60-CPP. Do not pass a nonstandard-layout type object across execution boundaries | 
  
   | DF4746 | CTR51-CPP. Use valid references, pointers, and iterators to reference elements of a container | 
  
   | DF4746 | STR52-CPP. Use valid references, pointers, and iterators to reference elements of a basic_string | 
  
   | DF4747 | CTR51-CPP. Use valid references, pointers, and iterators to reference elements of a container | 
  
   | DF4747 | STR52-CPP. Use valid references, pointers, and iterators to reference elements of a basic_string | 
  
   | DF4748 | CTR51-CPP. Use valid references, pointers, and iterators to reference elements of a container | 
  
   | DF4748 | STR52-CPP. Use valid references, pointers, and iterators to reference elements of a basic_string | 
  
   | DF4749 | CTR51-CPP. Use valid references, pointers, and iterators to reference elements of a container | 
  
   | DF4749 | STR52-CPP. Use valid references, pointers, and iterators to reference elements of a basic_string | 
  
   | DF4756 | ERR57-CPP. Do not leak resources when handling exceptions | 
  
   | DF4757 | ERR57-CPP. Do not leak resources when handling exceptions | 
  
   | DF4758 | ERR57-CPP. Do not leak resources when handling exceptions | 
  
   | DF4761 | MEM53-CPP. Explicitly construct and destruct objects when manually managing object lifetime | 
  
   | DF4762 | MEM53-CPP. Explicitly construct and destruct objects when manually managing object lifetime | 
  
   | DF4766 | MEM53-CPP. Explicitly construct and destruct objects when manually managing object lifetime | 
  
   | DF4767 | MEM53-CPP. Explicitly construct and destruct objects when manually managing object lifetime | 
  
   | DF4770 | STR51-CPP. Do not attempt to create a std::string from a null pointer | 
  
   | DF4771 | STR51-CPP. Do not attempt to create a std::string from a null pointer | 
  
   | DF4772 | STR51-CPP. Do not attempt to create a std::string from a null pointer | 
  
   | DF4773 | STR51-CPP. Do not attempt to create a std::string from a null pointer | 
  
   | DF4774 | STR51-CPP. Do not attempt to create a std::string from a null pointer | 
  
   | DF4776 | OOP56-CPP. Honor replacement handler requirements | 
  
   | DF4777 | OOP56-CPP. Honor replacement handler requirements | 
  
   | DF4778 | OOP56-CPP. Honor replacement handler requirements | 
  
   | DF4779 | OOP56-CPP. Honor replacement handler requirements | 
  
   | DF4786 | FIO51-CPP. Close files when they are no longer needed | 
  
   | DF4787 | FIO51-CPP. Close files when they are no longer needed | 
  
   | DF4788 | FIO51-CPP. Close files when they are no longer needed | 
  
   | DF4941 | DCL55-CPP. Avoid information leakage when passing a class object across a trust boundary | 
  
   | DF4942 | DCL55-CPP. Avoid information leakage when passing a class object across a trust boundary | 
  
   | DF4943 | DCL55-CPP. Avoid information leakage when passing a class object across a trust boundary | 
  
   | DF4962 | CON50-CPP. Do not destroy a mutex while it is locked |