GitHub
CERT Secure Coding

Helix QAC

This page was automatically generated and should not be edited.

The information on this page was provided by outside contributors and has not been verified by SEI CERT.

The table below can be re-ordered, by clicking column headers.

Tool Version: 2025.2

CheckerGuideline
C++0014DCL52-CPP. Never qualify a reference type with const or volatile
C++1067DCL60-CPP. Obey the one-definition rule
C++1109DCL53-CPP. Do not write syntactically ambiguous declarations
C++1509DCL60-CPP. Obey the one-definition rule
C++1510DCL60-CPP. Obey the one-definition rule
C++1552DCL56-CPP. Avoid cycles during initialization of static objects
C++1554DCL56-CPP. Avoid cycles during initialization of static objects
C++1704DCL56-CPP. Avoid cycles during initialization of static objects
C++1772CON53-CPP. Avoid deadlock by locking in a predefined order
C++1773CON53-CPP. Avoid deadlock by locking in a predefined order
C++1774CON52-CPP. Prevent data races when accessing bit-fields from multiple threads
C++1775CON52-CPP. Prevent data races when accessing bit-fields from multiple threads
C++1778CON55-CPP. Preserve thread safety and liveness when using condition variables
C++1779CON55-CPP. Preserve thread safety and liveness when using condition variables
C++2012DCL50-CPP. Do not define a C-style variadic function
C++2045DCL57-CPP. Do not let exceptions escape from destructors or deallocation functions
C++2047DCL57-CPP. Do not let exceptions escape from destructors or deallocation functions
C++2110MEM51-CPP. Properly deallocate dynamically allocated resources
C++2111MEM51-CPP. Properly deallocate dynamically allocated resources
C++2112MEM51-CPP. Properly deallocate dynamically allocated resources
C++2113MEM51-CPP. Properly deallocate dynamically allocated resources
C++2118MEM51-CPP. Properly deallocate dynamically allocated resources
C++2160DCL54-CPP. Overload allocation and deallocation functions as a pair in the same scope
C++2510DCL53-CPP. Do not write syntactically ambiguous declarations
C++2518DCL59-CPP. Do not define an unnamed namespace in a header file
C++2625DCL50-CPP. Do not define a C-style variadic function
C++2888MSC54-CPP. A signal handler must be a plain old function
C++3013INT50-CPP. Do not cast to an out-of-range enumeration value
C++3033EXP56-CPP. Do not call a function with a mismatched language linkage
C++3038EXP56-CPP. Do not call a function with a mismatched language linkage
C++3066EXP55-CPP. Do not access a cv-qualified object through a cv-unqualified type
C++3072OOP51-CPP. Do not slice derived objects
C++3073CTR56-CPP. Do not use pointer arithmetic on polymorphic objects
C++3112EXP57-CPP. Do not cast or delete pointers to incomplete classes
C++3119MEM54-CPP. Provide placement new with properly aligned pointers to sufficient storage capacity
C++3128MEM54-CPP. Provide placement new with properly aligned pointers to sufficient storage capacity
C++3129MEM57-CPP. Avoid using default operator new for over-aligned types
C++3139CTR50-CPP. Guarantee that container indices and iterators are within the valid range
C++3140CTR50-CPP. Guarantee that container indices and iterators are within the valid range
C++3161ERR62-CPP. Detect errors when converting a string to a number
C++3162STR53-CPP. Range check element access
C++3163STR53-CPP. Range check element access
C++3164STR53-CPP. Range check element access
C++3165STR53-CPP. Range check element access
C++3166EXP51-CPP. Do not delete an array through a pointer of the incorrect type
C++3180DCL58-CPP. Do not modify the standard namespaces
C++3181DCL58-CPP. Do not modify the standard namespaces
C++3182DCL58-CPP. Do not modify the standard namespaces
C++3220EXP50-CPP. Do not depend on the order of evaluation for side effects
C++3221EXP50-CPP. Do not depend on the order of evaluation for side effects
C++3222EXP50-CPP. Do not depend on the order of evaluation for side effects
C++3223EXP50-CPP. Do not depend on the order of evaluation for side effects
C++3225CTR58-CPP. Predicate function objects should not be mutable
C++3225MEM52-CPP. Detect and handle memory allocation errors
C++3226CTR58-CPP. Predicate function objects should not be mutable
C++3226MEM52-CPP. Detect and handle memory allocation errors
C++3227CTR58-CPP. Predicate function objects should not be mutable
C++3227MEM52-CPP. Detect and handle memory allocation errors
C++3228EXP50-CPP. Do not depend on the order of evaluation for side effects
C++3228CTR58-CPP. Predicate function objects should not be mutable
C++3228MEM52-CPP. Detect and handle memory allocation errors
C++3229CTR58-CPP. Predicate function objects should not be mutable
C++3229MEM52-CPP. Detect and handle memory allocation errors
C++3230CTR58-CPP. Predicate function objects should not be mutable
C++3231CTR58-CPP. Predicate function objects should not be mutable
C++3232CTR58-CPP. Predicate function objects should not be mutable
C++3233CTR58-CPP. Predicate function objects should not be mutable
C++3234CTR58-CPP. Predicate function objects should not be mutable
C++3240EXP52-CPP. Do not rely on side effects in unevaluated operands
C++3241EXP52-CPP. Do not rely on side effects in unevaluated operands
C++3293CTR57-CPP. Provide a valid ordering predicate
C++3337MEM51-CPP. Properly deallocate dynamically allocated resources
C++3339MEM51-CPP. Properly deallocate dynamically allocated resources
C++3402OOP52-CPP. Do not delete a polymorphic object without a virtual destructor
C++3403OOP52-CPP. Do not delete a polymorphic object without a virtual destructor
C++3404OOP52-CPP. Do not delete a polymorphic object without a virtual destructor
C++3508ERR60-CPP. Exception objects must be nothrow copy constructible
C++3510ERR53-CPP. Do not reference base classes or class data members in a constructor or destructor function-try-block handler
C++3802CTR53-CPP. Use valid iterator ranges
C++3809ERR59-CPP. Do not throw an exception across execution boundaries
C++3810ERR59-CPP. Do not throw an exception across execution boundaries
C++3852EXP58-CPP. Pass an object of the correct type to va_start
C++3853EXP58-CPP. Pass an object of the correct type to va_start
C++3915EXP59-CPP. Use offsetof() on valid types and members
C++3916EXP59-CPP. Use offsetof() on valid types and members
C++4003EXP54-CPP. Do not access an object outside of its lifetime
C++4026EXP54-CPP. Do not access an object outside of its lifetime
C++4030ERR54-CPP. Catch handlers should order their parameter types from most derived to least derived
C++4031ERR61-CPP. Catch exceptions by lvalue reference
C++4032DCL57-CPP. Do not let exceptions escape from destructors or deallocation functions
C++4035ERR51-CPP. Handle all exceptions
C++4035ERR55-CPP. Honor exception specifications
C++4036ERR51-CPP. Handle all exceptions
C++4036ERR55-CPP. Honor exception specifications
C++4037ERR51-CPP. Handle all exceptions
C++4053OOP53-CPP. Write constructor member initializers in the canonical order
C++4072OOP54-CPP. Gracefully handle self-copy assignment
C++4073OOP54-CPP. Gracefully handle self-copy assignment
C++4075ERR56-CPP. Guarantee exception safety
C++4075OOP54-CPP. Gracefully handle self-copy assignment
C++4075OOP58-CPP. Copy operations must not mutate the source object
C++4076ERR56-CPP. Guarantee exception safety
C++4076OOP54-CPP. Gracefully handle self-copy assignment
C++4260OOP50-CPP. Do not invoke virtual functions from constructors or destructors
C++4261OOP50-CPP. Do not invoke virtual functions from constructors or destructors
C++4262MEM51-CPP. Properly deallocate dynamically allocated resources
C++4263MEM51-CPP. Properly deallocate dynamically allocated resources
C++4264MEM51-CPP. Properly deallocate dynamically allocated resources
C++4273OOP50-CPP. Do not invoke virtual functions from constructors or destructors
C++4274OOP50-CPP. Do not invoke virtual functions from constructors or destructors
C++4275OOP50-CPP. Do not invoke virtual functions from constructors or destructors
C++4276OOP50-CPP. Do not invoke virtual functions from constructors or destructors
C++4277OOP50-CPP. Do not invoke virtual functions from constructors or destructors
C++4278OOP50-CPP. Do not invoke virtual functions from constructors or destructors
C++4279OOP50-CPP. Do not invoke virtual functions from constructors or destructors
C++4280OOP50-CPP. Do not invoke virtual functions from constructors or destructors
C++4281OOP50-CPP. Do not invoke virtual functions from constructors or destructors
C++4282OOP50-CPP. Do not invoke virtual functions from constructors or destructors
C++4303MEM50-CPP. Do not access freed memory
C++4304MEM50-CPP. Do not access freed memory
C++4631DCL57-CPP. Do not let exceptions escape from destructors or deallocation functions
C++4632MEM52-CPP. Detect and handle memory allocation errors
C++4632ERR55-CPP. Honor exception specifications
C++4634ERR58-CPP. Handle all exceptions thrown before main() begins executing
C++4636ERR58-CPP. Handle all exceptions thrown before main() begins executing
C++4637ERR58-CPP. Handle all exceptions thrown before main() begins executing
C++4639ERR54-CPP. Catch handlers should order their parameter types from most derived to least derived
C++4639ERR58-CPP. Handle all exceptions thrown before main() begins executing
C++4671EXP55-CPP. Do not access a cv-qualified object through a cv-unqualified type
C++4986CON56-CPP. Do not speculatively lock a non-recursive mutex that is already owned by the calling thread
C++4987CON56-CPP. Do not speculatively lock a non-recursive mutex that is already owned by the calling thread
C++5003DCL51-CPP. Do not declare or define a reserved identifier
C++5014ERR50-CPP. Do not abruptly terminate the program
C++5015ERR52-CPP. Do not use setjmp() or longjmp()
C++5017OOP57-CPP. Prefer special member functions and overloaded operators to C Standard Library functions
C++5018CON51-CPP. Ensure actively held locks are released on exceptional conditions
C++5019CON54-CPP. Wrap functions that can spuriously wake up in a loop
C++5028MSC50-CPP. Do not use std::rand() for generating pseudorandom numbers
C++5038OOP57-CPP. Prefer special member functions and overloaded operators to C Standard Library functions
C++5041MSC51-CPP. Ensure your random number generator is properly seeded
C++5216STR50-CPP. Guarantee that storage for strings has sufficient space for character data and the null terminator
DF726EXP53-CPP. Do not read uninitialized memory
DF961CON50-CPP. Do not destroy a mutex while it is locked
DF978EXP53-CPP. Do not read uninitialized memory
DF2668CTR54-CPP. Do not subtract iterators that do not refer to the same container
DF2727EXP53-CPP. Do not read uninitialized memory
DF2728EXP53-CPP. Do not read uninitialized memory
DF2761CTR54-CPP. Do not subtract iterators that do not refer to the same container
DF2762CTR54-CPP. Do not subtract iterators that do not refer to the same container
DF2763CTR54-CPP. Do not subtract iterators that do not refer to the same container
DF2766CTR54-CPP. Do not subtract iterators that do not refer to the same container
DF2767CTR54-CPP. Do not subtract iterators that do not refer to the same container
DF2768CTR54-CPP. Do not subtract iterators that do not refer to the same container
DF2810OOP55-CPP. Do not use pointer-to-member operators to access nonexistent members
DF2811OOP55-CPP. Do not use pointer-to-member operators to access nonexistent members
DF2812EXP54-CPP. Do not access an object outside of its lifetime
DF2812OOP55-CPP. Do not use pointer-to-member operators to access nonexistent members
DF2813EXP54-CPP. Do not access an object outside of its lifetime
DF2813OOP55-CPP. Do not use pointer-to-member operators to access nonexistent members
DF2814EXP54-CPP. Do not access an object outside of its lifetime
DF2814OOP55-CPP. Do not use pointer-to-member operators to access nonexistent members
DF2835STR50-CPP. Guarantee that storage for strings has sufficient space for character data and the null terminator
DF2836STR50-CPP. Guarantee that storage for strings has sufficient space for character data and the null terminator
DF2839STR50-CPP. Guarantee that storage for strings has sufficient space for character data and the null terminator
DF2886MSC53-CPP. Do not return from a function declared [[noreturn]]
DF2888MSC52-CPP. Value-returning functions must return a value from all exit paths
DF2891CTR50-CPP. Guarantee that container indices and iterators are within the valid range
DF2930EXP54-CPP. Do not access an object outside of its lifetime
DF2931EXP54-CPP. Do not access an object outside of its lifetime
DF2932EXP54-CPP. Do not access an object outside of its lifetime
DF2933EXP54-CPP. Do not access an object outside of its lifetime
DF2934EXP54-CPP. Do not access an object outside of its lifetime
DF2961EXP53-CPP. Do not read uninitialized memory
DF2962EXP53-CPP. Do not read uninitialized memory
DF2963EXP53-CPP. Do not read uninitialized memory
DF2966EXP53-CPP. Do not read uninitialized memory
DF2967EXP53-CPP. Do not read uninitialized memory
DF2968EXP53-CPP. Do not read uninitialized memory
DF2971EXP53-CPP. Do not read uninitialized memory
DF2972EXP53-CPP. Do not read uninitialized memory
DF2973EXP53-CPP. Do not read uninitialized memory
DF2976EXP53-CPP. Do not read uninitialized memory
DF2977EXP53-CPP. Do not read uninitialized memory
DF3520MEM54-CPP. Provide placement new with properly aligned pointers to sufficient storage capacity
DF3521MEM54-CPP. Provide placement new with properly aligned pointers to sufficient storage capacity
DF3522MEM54-CPP. Provide placement new with properly aligned pointers to sufficient storage capacity
DF3523MEM54-CPP. Provide placement new with properly aligned pointers to sufficient storage capacity
DF3526CTR52-CPP. Guarantee that library functions do not overflow
DF3526CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow
DF3527CTR52-CPP. Guarantee that library functions do not overflow
DF3527CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow
DF3528CTR52-CPP. Guarantee that library functions do not overflow
DF3528CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow
DF3529CTR52-CPP. Guarantee that library functions do not overflow
DF3529CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow
DF3530CTR52-CPP. Guarantee that library functions do not overflow
DF3530CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow
DF3531CTR52-CPP. Guarantee that library functions do not overflow
DF3531CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow
DF3532CTR52-CPP. Guarantee that library functions do not overflow
DF3532CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow
DF3533CTR52-CPP. Guarantee that library functions do not overflow
DF3533CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow
DF3534CTR52-CPP. Guarantee that library functions do not overflow
DF3534CTR55-CPP. Do not use an additive operator on an iterator if the result would overflow
DF4701EXP63-CPP. Do not rely on the value of a moved-from object
DF4702EXP63-CPP. Do not rely on the value of a moved-from object
DF4703EXP63-CPP. Do not rely on the value of a moved-from object
DF4706EXP61-CPP. A lambda object must not outlive any of its reference captured objects
DF4707EXP61-CPP. A lambda object must not outlive any of its reference captured objects
DF4708EXP61-CPP. A lambda object must not outlive any of its reference captured objects
DF4711FIO50-CPP. Do not alternately input and output from a file stream without an intervening positioning call
DF4712FIO50-CPP. Do not alternately input and output from a file stream without an intervening positioning call
DF4713FIO50-CPP. Do not alternately input and output from a file stream without an intervening positioning call
DF4721MEM56-CPP. Do not store an already-owned pointer value in an unrelated smart pointer
DF4722MEM56-CPP. Do not store an already-owned pointer value in an unrelated smart pointer
DF4723MEM56-CPP. Do not store an already-owned pointer value in an unrelated smart pointer
DF4726EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation
DF4727EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation
DF4728EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation
DF4729EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation
DF4731EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation
DF4732EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation
DF4733EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation
DF4734EXP62-CPP. Do not access the bits of an object representation that are not part of the object's value representation
DF4736MEM55-CPP. Honor replacement dynamic storage management requirements
DF4737MEM55-CPP. Honor replacement dynamic storage management requirements
DF4738MEM55-CPP. Honor replacement dynamic storage management requirements
DF4739MEM55-CPP. Honor replacement dynamic storage management requirements
DF4741EXP60-CPP. Do not pass a nonstandard-layout type object across execution boundaries
DF4742EXP60-CPP. Do not pass a nonstandard-layout type object across execution boundaries
DF4743EXP60-CPP. Do not pass a nonstandard-layout type object across execution boundaries
DF4746CTR51-CPP. Use valid references, pointers, and iterators to reference elements of a container
DF4746STR52-CPP. Use valid references, pointers, and iterators to reference elements of a basic_string
DF4747CTR51-CPP. Use valid references, pointers, and iterators to reference elements of a container
DF4747STR52-CPP. Use valid references, pointers, and iterators to reference elements of a basic_string
DF4748CTR51-CPP. Use valid references, pointers, and iterators to reference elements of a container
DF4748STR52-CPP. Use valid references, pointers, and iterators to reference elements of a basic_string
DF4749CTR51-CPP. Use valid references, pointers, and iterators to reference elements of a container
DF4749STR52-CPP. Use valid references, pointers, and iterators to reference elements of a basic_string
DF4756ERR57-CPP. Do not leak resources when handling exceptions
DF4757ERR57-CPP. Do not leak resources when handling exceptions
DF4758ERR57-CPP. Do not leak resources when handling exceptions
DF4761MEM53-CPP. Explicitly construct and destruct objects when manually managing object lifetime
DF4762MEM53-CPP. Explicitly construct and destruct objects when manually managing object lifetime
DF4766MEM53-CPP. Explicitly construct and destruct objects when manually managing object lifetime
DF4767MEM53-CPP. Explicitly construct and destruct objects when manually managing object lifetime
DF4770STR51-CPP. Do not attempt to create a std::string from a null pointer
DF4771STR51-CPP. Do not attempt to create a std::string from a null pointer
DF4772STR51-CPP. Do not attempt to create a std::string from a null pointer
DF4773STR51-CPP. Do not attempt to create a std::string from a null pointer
DF4774STR51-CPP. Do not attempt to create a std::string from a null pointer
DF4776OOP56-CPP. Honor replacement handler requirements
DF4777OOP56-CPP. Honor replacement handler requirements
DF4778OOP56-CPP. Honor replacement handler requirements
DF4779OOP56-CPP. Honor replacement handler requirements
DF4786FIO51-CPP. Close files when they are no longer needed
DF4787FIO51-CPP. Close files when they are no longer needed
DF4788FIO51-CPP. Close files when they are no longer needed
DF4941DCL55-CPP. Avoid information leakage when passing a class object across a trust boundary
DF4942DCL55-CPP. Avoid information leakage when passing a class object across a trust boundary
DF4943DCL55-CPP. Avoid information leakage when passing a class object across a trust boundary
DF4962CON50-CPP. Do not destroy a mutex while it is locked