CodeCheck Documentation
CodeCheck Documentation - C

Language: C

Check IDCheck NameSupportedAutomationCategorySeverity
A0-1-1A project shall not contain instances of non-volatile variables being given values that are not subsequently usedYesAutomatedRequired
A0-1-2The value returned by a function shall be usedYesAutomatedRequired
A0-1-3Every function defined in an anonymous namespace, or static function with internal linkage, or private member function shall be usedYesAutomatedRequired
A0-1-4There shall be no unused named parameters in non-virtual functionsYesAutomatedRequired
A0-1-5There shall be no unused named parameters in the set of parameters for a virtual function and all the functions that override itYesAutomatedRequired
A0-1-6There should be no unused type declarationsYesAutomatedAdvisory
A0-4-1Floating-point implementation shall comply with IEEE 754 standardNoNon-automatedRequired
A0-4-2Type long double shall not be usedYesAutomatedRequired
A1-1-2A warning level of the compilation process shall be set in compliance with project policiesNoNon-automatedRequired
A1-4-3All code should compile free of compiler warningsYesAutomatedAdvisory
A2-3-1Only those characters specified in the C++ Language Standard basic source character set shall be used in the source codeYesAutomatedRequired
A2-5-12-3-1 Trigraphs shall not be usedYesAutomatedRequired
A2-5-2Digraphs shall not be usedYesAutomatedRequired
A2-7-1The character \ shall not occur as a last character of a C++ commentYesAutomatedRequired
A2-7-2Sections of code shall not be "commented out"YesNon-automatedRequired
A2-7-3All declarations of "user-defined" types, static and non-static data members, functions and methods shall be preceded by documentationYesAutomatedRequired
A2-8-1A header file name should reflect the logical entity for which it provides declarationsYesNon-automatedRequired
A2-8-2An implementation file name should reflect the logical entity for which it provides definitionsYesNon-automatedAdvisory
A2-10-1Shadowed IdentifiersYesAutomatedRequired
A2-10-4The identifier name of a non-member object with static storage duration or static function shall not be reused within a namespaceYesAutomatedRequired
A2-10-5An identifier name of a function with static storage duration or a non-member object with external or internal linkage should not be reusedYesAutomatedAdvisory
A2-10-6A class or enumeration name shall not be hidden by a variable, function or enumerator declaration in the same scopeYesAutomatedRequired
A2-11-1Volatile keyword shall not be usedYesAutomatedRequired
A2-13-1Only those escape sequences that are defined in ISO/IEC 14882:2014 shall be usedYesAutomatedRequired
A2-13-2Concatenating String Literals of Different EncodingsYes
A2-13-3Type wchar_t shall not be usedYesAutomatedRequired
A2-13-4String literals shall not be assigned to non-constant pointersYesAutomatedRequired
A2-13-5Hexadecimal constants should be upper caseYesAutomatedAdvisory
A2-13-6Universal character names shall be used only inside character or string literalsYesAutomatedRequired
A3-1-1It shall be possible to include any header file in multiple translation units without violating the One Definition RuleYesAutomatedRequired
A3-1-2Header files, that are defined locally in the project, shall have a file name extension of one of: ".h", ".hpp" or ".hxx"YesAutomatedRequired
A3-1-3Implementation files, that are defined locally in the project, should have a file name extension of ".cpp"YesAutomatedAdvisory
A3-1-4When an array with external linkage is declared, its size shall be stated explicitlyYesAutomatedRequired
A3-1-5A function definition shall only be placed in a class definition if (1) the function is intended to be inlined (2) it is a member function template (3) it is a member function of a class templateYesPartially AutomatedRequired
A3-1-6Trivial accessor and mutator functions should be inlined.YesAutomatedAdvisory
A3-3-1Objects or functions with external linkage (including members of named namespaces) shall be declared in a header fileYesAutomatedRequired
A3-3-2Static and thread-local objects shall be constant-initializedYesAutomatedRequired
A3-9-1Fixed Width IntegersYesAutomatedRequired
A4-5-1Expressions with type enum or enum class shall not be used as operands to built-in and overloaded operators other than the subscript operator [ ], the assignment operator =, the equality operators == and ! =, the unary & operator, and the relational operators <, <=, >, >=YesAutomatedRequired
A4-7-1An integer expression shall not lead to data loss.YesAutomatedRequired
A4-10-1Only nullptr literal shall be used as the null-pointer-constantYesAutomatedRequired
A5-0-1The value of an expression shall be the same under any order of evaluation that the standard permitsYesAutomatedRequired
A5-0-2Condition of if statement shall be boolYesAutomatedRequired
A5-0-3No more than 2 levels of pointer indirectionYesAutomatedRequired
A5-0-4Pointer arithmetic shall not be used with pointers to non-final classesYesAutomatedRequired
A5-1-1Literal values shall not be used apart from type initialization, otherwise symbolic names shall be used insteadYesAutomatedRequired
A5-1-2Variables shall not be implicitly captured in a lambda expressionYesAutomatedRequired
A5-1-3Parameter list (possibly empty) shall be included in every lambda expressionYesAutomatedRequired
A5-1-4A lambda expression object shall not outlive any of its reference-captured objectsYesAutomatedRequired
A5-1-6Specify Lambda Return TypeYesAutomatedAdvisory
A5-1-7A lambda shall not be an operand to decltype or typeidYesAutomatedRequired
A5-1-8Lambda expressions should not be defined inside another lambda expressionYesAutomatedAdvisory
A5-1-9Identical unnamed lambda expressions shall be replaced with a named function or a named lambda expressionYesAutomatedAdvisory
A5-2-1dynamic_cast should not be usedYesAutomatedAdvisory
A5-2-2Traditional C-style casts shall not be usedYesAutomatedRequired
A5-2-3A cast shall not remove any const or volatile qualification from the type of a pointer or referenceYesAutomatedRequired
A5-2-4reinterpret_cast shall not be usedYesAutomatedRequired
A5-2-5AAn array or container shall not be accessed beyond its range (Part A)YesAutomatedRequired
A5-2-5BAn array or container shall not be accessed beyond its range Part BYesAutomatedRequired
A5-2-6Operands of Logical Boolean OperatorsYesAutomatedRequired
A5-3-1Evaluation of the operand to the typeid operator shall not contain side effects.YesNon-automatedRequired
A5-3-2Before dereferencing a pointer, compare it with NULLYesPartially AutomatedRequired
A5-3-3Deleting Pointers to Incomplete Class TypesYesAutomatedRequired
A5-5-1A pointer to member shall not access non-existent class membersYesAutomatedRequired
A5-6-1AThe right hand operand of the integer division or remainder operators shall not be equal to zeroYesAutomatedRequired
A5-6-1BThe right hand operand of the integer division or remainder operators shall not be equal to zeroYesAutomatedRequired
A5-10-1A pointer to member virtual function shall only be tested for equality with null-pointer-constantYesAutomatedRequired
A5-16-1The ternary conditional operator shall not be used as a sub-expressionYesAutomatedRequired
A6-2-1Move and copy assignment operators shall either move or respectively copy base classes and data members of a class, without any side effectsYesAutomatedRequired
A6-2-2Explicit Calls to Constructors of Temporary ObjectsYesAutomatedRequired
A6-4-1A switch statement shall have at least two case-clauses, distinct from the default labelYesAutomatedRequired
A6-5-1A for-loop that loops through all elements of the container and does not use its loop-counter shall not be usedYesAutomatedRequired
A6-5-2A for loop shall contain a single loop-counter which shall not have floating-point typeYesAutomatedRequired
A6-5-3Do statements should not be usedYesAutomatedAdvisory
A6-5-4For-init-statement and expression should not perform actions other than loop-counter initialization and modificationYesAutomatedAdvisory
A6-6-1The goto statement shall not be used.YesAutomatedRequired
A7-1-1Constexpr or const specifiers shall be used for immutable data declarationYesAutomatedRequired
A7-1-2The constexpr specifier shall be used for values that can be determined at compile timeYesAutomatedRequired
A7-1-3CV-qualifiers shall be placed on the right hand side of the type that is a typedef or a using nameYesAutomatedRequired
A7-1-4The register keyword shall not be usedYesAutomatedRequired
A7-1-5The auto specifier shall not be used apart from following cases: (1) to declare that a variable has the same type as return type of a function call, (2) to declare that a variable has the same type as initializer of non-fundamental type, (3) to declare parameters of a generic lambda expression, (4) to declare a function template using trailing return type syntaxYesAutomatedRequired
A7-1-6The typedef specifier shall not be usedYesAutomatedRequired
A7-1-7Each expression statement and identifier declaration shall be placed on a separate lineYesAutomatedRequired
A7-1-8A non-type specifier shall be placed before a type specifier in a declaration.YesAutomatedRequired
A7-1-9A class, structure, or enumeration shall not be declared in the definition of its typeYesAutomatedRequired
A7-2-1An expression with enum underlying type shall only have values corresponding to the enumerators of the enumerationYesAutomatedRequired
A7-2-2Enumeration underlying base type shall be explicitly definedYesAutomatedRequired
A7-2-3Enumerations shall be declared as scoped enum classesYesAutomatedRequired
A7-2-4In an enumeration, either (1) none, (2) the first or (3) all enumerators shall be initializedYesAutomatedRequired
A7-3-1Overloaded Function Not Visible From Where it is CalledYesAutomatedRequired
A7-4-1The asm declaration shall not be used.YesAutomatedRequired
A7-5-1A function shall not return a reference or a pointer to a parameter that is passed by reference to const.YesAutomatedRequired
A7-5-2Functions shall not call themselves, either directly or indirectly.YesAutomatedRequired
A7-6-1Functions declared with the [[noreturn]] attribute shall not returnYesAutomatedRequired
A8-2-1When declaring function templates, the trailing return type syntax shall be used if the return type depends on the type of parameters.YesAutomatedRequired
A8-4-1Functions shall not be defined using the ellipsis notation.YesAutomatedRequired
A8-4-2Always return a value in non-void functionsYesAutomatedRequired
A8-4-3Common ways of passing parameters should be used.YesAutomatedRequired
A8-4-4Multiple output values from a function should be returned as a struct or tuple.YesAutomatedAdvisory
A8-4-5"consume" parameters declared as X && shall always be moved from.YesAutomatedRequired
A8-4-6"forward" parameters declared as T && shall always be forwarded.YesAutomatedRequired
A8-4-7"in" parameters for "cheap to copy" types shall be passed by value.YesAutomatedRequired
A8-4-8Output parameters shall not be used.YesAutomatedRequired
A8-4-9"in-out" parameters declared as T & shall be modified.YesAutomatedRequired
A8-4-10A parameter shall be passed by reference if it can't be NULLYesAutomatedRequired
A8-4-11A smart pointer shall only be used as a parameter type if it expresses lifetime semanticsYesAutomatedRequired
A8-4-12Invalid Use of std::unique_ptrYesAutomatedRequired
A8-4-13Invalid Use of std::shared_ptrYesAutomatedRequired
A8-5-0Uninitialized Memory ReadYesAutomatedRequired
A8-5-1Incorrect Order of InitializationYesAutomatedRequired
A8-5-2Initializing Variables Without Using Braced-InitializationYesAutomatedRequired
A8-5-3Auto VariableYesAutomatedRequired
A8-5-4Class Constructor with Parameter Type std::initializer_listYesAutomatedAdvisory
A9-3-1Member functions shall not return non-const raw pointers or references to private or protected data owned by the classYesAutomatedRequired
A9-5-1Unions Shall not be UsedYesAutomatedRequired
A9-6-1Data types used for interfacingYesPartially AutomatedRequired
A10-0-1Public Inheritance not Used in a "is-a" RelationshipYesNon-automatedRequired
A10-0-2Membership or non-public inheritance shall be used to implement "has-a" relationshipNoNon-automatedRequired
A10-1-1Multiple Base ClassesYesAutomatedRequired
A10-2-1Non-virtual public or protected member functions shall not be redefined in derived classesYesAutomatedRequired
A10-3-1Virtual function declaration shall contain exactly one of the three specifiers: (1) virtual, (2) override, (3) finalYesAutomatedRequired
A10-3-3Virtual functions shall not be introduced in a final classYesAutomatedRequired
A10-3-5User-defined assignment operator shall not be virtualYesAutomatedRequired
A10-4-1Hierarchies should be based on interface classesYesNon-automatedAdvisory
A11-0-1A non-POD type should be defined as classYesAutomatedAdvisory
A11-0-2A type defined as struct shall: (1) provide only public data members, (2) not provide any special member functions or methods, (3) not be a base of another struct or class, (4) not inherit from another struct or classYesAutomatedRequired
A11-3-1Friend declarations shall not be used.YesAutomatedRequired
A12-0-1If a class declares a copy or move operation, or a destructor, either via "=default", "=delete", or via a user-provided declaration, then all others of these five special member functions shall be declared as well.YesAutomatedRequired
A12-0-2Bitwise operations and operations that assume data representation in memory shall not be performed on objects.YesAutomatedRequired
A12-1-1Constructors shall explicitly initialize all virtual base classes, all direct non-virtual base classes and all non-static data members.YesAutomatedRequired
A12-1-2Both NSDMI and a non-static member initializer in a constructor shall not be used in the same type.YesAutomatedRequired
A12-1-3If all user-defined constructors of a class initialize data members with constant values that are the same across all constructors, then data members shall be initialized using NSDMI instead.YesAutomatedRequired
A12-1-4All constructors that are callable with a single argument of fundamental type shall be declared explicit.YesAutomatedRequired
A12-1-5Common class initialization for non-constant members shall be done by a delegating constructor.YesPartially AutomatedRequired
A12-1-6Derived classes that do not need further explicit initialization and require all the constructors from the base class shall use inheriting constructorsNoAutomatedRequired
A12-4-1Destructor of a base class shall be public virtual, public override or protected non-virtualYesAutomatedRequired
A12-4-2If a public destructor of a class is non-virtual, then the class should be declared final.YesAutomatedAdvisory
A12-6-1All class data members that are initialized by the constructor shall be initialized using member initializers.YesAutomatedRequired
A12-7-1If the behavior of a user-defined special member function is identical to implicitly defined special member function, then it shall be defined =default or be left undefined.YesAutomatedRequired
A12-8-1Move and copy constructors shall move and respectively copy base classes and data members of a class, without any side effectsYesAutomatedRequired
A12-8-2User-defined copy and move assignment operators should use user-defined no-throw swap function.YesAutomatedAdvisory
A12-8-3Moved-from object shall not be read-accessed.YesPartially AutomatedAdvisory
A12-8-4Move constructor shall not initialize its class members and base classes using copy semantics.YesAutomatedRequired
A12-8-5A copy assignment and a move assignment operators shall handle self-assignment.YesAutomatedRequired
A12-8-6Copy and move constructors and copy assignment and move assignment operators shall be declared protected or defined "=delete" in base class.YesAutomatedRequired
A12-8-7Assignment operators should be declared with the ref-qualifier &.YesAutomatedAdvisory
A13-1-2User defined suffixes of the user defined literal operators shall start with underscore followed by one or more lettersYesAutomatedRequired
A13-1-3User defined literals operators shall only perform conversion of passed parametersYesAutomatedRequired
A13-2-1An assignment operator shall return a reference to "this"YesAutomatedRequired
A13-2-2A binary arithmetic operator and a bitwise operator shall return a "prvalue"YesAutomatedRequired
A13-2-3A relational operator shall return a boolean valueYesAutomatedRequired
A13-3-1A function that contains "forwarding reference" as its argument shall not be overloadedYesAutomatedRequired
A13-5-1If "operator[]" is to be overloaded with a non-const version, const version shall also be implementedYesAutomatedRequired
A13-5-2All user-defined conversion operators shall be defined explicitYesAutomatedRequired
A13-5-3User-defined conversion operators should not be usedYesAutomatedAdvisory
A13-5-4If two opposite operators are defined, one shall be defined in terms of the otherYesAutomatedRequired
A13-5-5Comparison operators shall be non-member functions with identical parameter types and noexceptYesAutomatedRequired
A13-6-1Digit sequences separators ' shall only be used as follows: (1) for decimal, every 3 digits, (2) for hexadecimal, every 2 digits, (3) for binary, every 4 digitsYesAutomatedRequired
A14-1-1A template should check if a specific template argument is suitable for this templateYesNon-automatedAdvisory
A14-5-1A template constructor shall not participate in overload resolution for a single argument of the enclosing class typeYesAutomatedRequired
A14-5-2Class members that are not dependent on template class parameters should be defined in a separate base classYesPartially AutomatedAdvisory
A14-5-3A non-member generic operator shall only be declared in a namespace that does not contain class (struct) type, enum type or union type declarationsYesAutomatedAdvisory
A14-7-1A type used as a template argument shall provide all members that are used by the templateYesAutomatedRequired
A14-7-2Template specialization shall be declared in the same file as the primary templateYesAutomatedRequired
A14-8-2Explicit specializations of function templates shall not be usedYesAutomatedRequired
A15-0-1A function shall not exit with an exception if it is able to complete its taskNoNon-automatedRequired
A15-0-2At least the basic guarantee for exception safety shall be provided for all operations. In addition, each function may offer either the strong guarantee or the nothrow guaranteeNoPartially AutomatedRequired
A15-0-3Exception safety guarantee of a called function shall be consideredNoNon-automatedRequired
A15-0-4Unchecked exceptions shall be used to represent errors from which the caller cannot reasonably be expected to recover.NoNon-automatedRequired
A15-0-5Checked exceptions shall be used to represent errors from which the caller can reasonably be expected to recoverNoNon-automatedRequired
A15-0-6An analysis shall be performed to analyze the failure modes of exception handlingNoNon-automatedRequired
A15-0-7Exception handling mechanism shall guarantee a deterministic worst-case time execution timeNoPartially AutomatedRequired
A15-0-8A worst-case execution time (WCET) analysis shall be performed to determine maximum execution time constraints of the software, covering in particular the exceptions processingNoNon-automatedRequired
A15-1-1Only instances of types derived from std::exception should be thrownYesAutomatedAdvisory
A15-1-2An exception object shall not be a pointerYesAutomatedRequired
A15-1-3All thrown exceptions should be uniqueYesAutomatedAdvisory
A15-1-4If a function exits with an exception, then before a throw, the function shall place all objects/resources that the function constructed in valid states or it shall delete themYesPartially AutomatedRequired
A15-2-1Constructors that are not noexcept shall not be invoked before program startupYesAutomatedRequired
A15-2-2If a constructor is not noexcept and the constructor cannot finish object initialization, then it shall deallocate the object's resources and it shall throw an exceptionYesPartially AutomatedRequired
A15-3-3Unhandled Exceptions on Main FunctionYesPartially AutomatedRequired
A15-3-4Catch-all (ellipsis and std::exception) handlers shall be used only in (a) main, (b) task main functions, (c) in functions that are supposed to isolate independent components and (d) when calling third-party code that uses exceptions not according to AUTOSAR C++14 guidelines YesNon-automatedRequired
A15-3-5A class type exception shall be caught by reference or const referenceYesAutomatedRequired
A15-4-1Dynamic exception-specification shall not be used YesAutomatedRequired
A15-4-2If a function is declared to be noexcept, noexcept(true) or noexcept(<truecondition>), then it shall not exit with an exceptionYesAutomatedRequired
A15-4-3The noexcept specification of a function shall either be identical across all translation units, or identical or more restrictive between a virtual member function and an overriderYesAutomatedRequired
A15-4-4A declaration of non-throwing function shall contain noexcept specificationYesAutomatedRequired
A15-4-5Checked exceptions that could be thrown from a function shall be specified together with the function declaration and they shall be identical in all function declarations and for all its overriders.YesAutomatedRequired
A15-5-1All user-provided class destructors, deallocation functions, move constructors, move assignment operators and swap functions shall not exit with an exception. A noexcept exception specification shall be added to these functions as appropriateYesAutomatedRequired
A15-5-2Program shall not be abruptly terminatedYesAutomatedRequired
A15-5-3The std::terminate() function shall not be called implicitlyYesAutomatedRequired
A16-0-1Incorrect Use of Pre-processorYesAutomatedRequired
A16-2-1Header File NameYesAutomatedRequired
A16-2-2There shall be no unused include directives (slow)YesAutomatedRequired
A16-6-1#error directive shall not be usedYesAutomatedRequired
A16-7-1The #pragma directive shall not be usedYesAutomatedRequired
A17-0-1Reserved Builtin MacrosYesAutomatedRequired
A17-6-1Non-standard entities shall not be added to standard namespacesYesAutomatedRequired
A18-0-1The C library facilities shall only be accessed through C++ library headersYesAutomatedRequired
A18-0-2The error state of a conversion from string to a numeric value shall be checkedYesAutomatedRequired
A18-0-3Library <clocale> (locale.h)YesAutomatedRequired
A18-1-1C-style ArrayYesAutomatedRequired
A18-1-2The std::vector<bool> specialization shall not be usedYesAutomatedRequired
A18-1-3The std::auto_ptr type shall not be usedYesAutomatedRequired
A18-1-4A pointer pointing to an element of an array of objects shall not be passed to a smart pointer of single object typeYesAutomatedRequired
A18-1-6All std::hash specializations for user-defined types shall have a noexcept function call operatorYesAutomatedRequired
A18-5-1Functions malloc, calloc, realloc and free shall not be usedYesAutomatedRequired
A18-5-2Non-placement new or delete expressions shall not be usedYesPartially AutomatedRequired
A18-5-3The form of the delete expression shall match the form of the new expression used to allocate the memoryYesAutomatedRequired
A18-5-4If a project has a sized or unsized version of operator "delete" globally defined, then both sized and unsized versions shall be definedYesAutomatedRequired
A18-5-7Dynamic Memory Usage on Realtime PhaseYesNon-automatedRequired
A18-5-8Objects that do not outlive a function shall have automatic storage durationYesPartially AutomatedRequired
A18-5-9New Method Throwing an ExceptionYesAutomatedRequired
A18-5-11operator "new" and operator "delete" shall be defined togetherYesAutomatedRequired
A18-9-1The std::bind shall not be usedYesAutomatedRequired
A18-9-2Forwarding values to other functions shall be done via: (1) std::move if the value is an rvalue reference, (2) std::forward if the value is forwarding referenceYesAutomatedRequired
A18-9-3The std::move shall not be used on objects declared const or const&YesAutomatedRequired
A18-9-4An argument to std::forward shall not be subsequently usedYesAutomatedRequired
A20-8-1An already-owned pointer value shall not be stored in an unrelated smart pointerYesAutomatedRequired
A20-8-2A std::unique_ptr shall be used to represent exclusive ownershipYesAutomatedRequired
A20-8-3A std::shared_ptr shall be used to represent shared ownershipYesAutomatedRequired
A20-8-4A std::unique_ptr shall be used over std::shared_ptr if ownership sharing is not requiredYesAutomatedRequired
A20-8-5std::make_unique shall be used to construct objects owned by std::unique_ptrYesAutomatedRequired
A20-8-6std::make_shared shall be used to construct objects owned by std::shared_ptrYesAutomatedRequired
A20-8-7Cyclic Structure of std::shared_ptrYesNon-automatedRequired
A21-8-1Arguments to character-handling functions shall be representable as an unsigned charYesAutomatedRequired
A23-0-1An iterator shall not be implicitly converted to const_iteratorYesAutomatedRequired
A25-1-1Predicate Function Objects Copied IncorrectlyYesAutomatedRequired
A26-5-1Pseudorandom numbers shall not be generated using std::rand()YesAutomatedRequired
A26-5-2Random number engines shall not be default-initializedYesAutomatedRequired
A27-0-1Inputs from independent components shall be validatedYesNon-automatedRequired
A27-0-3Alternate input and output operations on a file stream shall not be used without an intervening flush or positioning callYesAutomatedRequired
A27-0-4C-style strings shall not be usedYesAutomatedRequired
AC_00No Control Code CharactersYes
AC_01No Direct or Indirect RecursionYes
AC_HIS_02Number of Paths(PATH)Yes
AC_HIS_04Cyclomatic Complexity (v(G))Yes
AC_HIS_05Calling Functions (CALLING)Yes
AC_HIS_06Called Functions (CALLS)Yes
AC_HIS_07Function Parameters (PARAM)Yes
AC_HIS_08Number of Staments (STMT)Yes
AC_HIS_09Number of call levels (LEVEL)Yes
AC_HIS_10Number of return points (RETURN)Yes
AC_HIS_11Language scope (VOCF)Yes
AC_HIS_12Recursion (AP_CG_CYCLE)Yes
AC_HIS_13Statements Changed (SCHG)Yes
AC_HIS_14Statements Deleted (SDEL)Yes
AC_HIS_15New Statements (SNEW)Yes
AC_HIS_16Stability Index (S)Yes
ARR30-CDo not form or use out-of-bounds pointers or array subscriptsNoHigh
ARR32-CEnsure size arguments for variable length arrays are in a valid rangeNoHigh
ARR36-CDo not subtract or compare two pointers that do not refer to the same arrayYesMedium
ARR37-CDo not add or subtract an integer to a pointer to a non-array objectYesMedium
ARR38-CGuarantee that library functions do not form invalid pointersNoHigh
ARR39-CDo not add or subtract a scaled integer to a pointerYesHigh
CON30-CClean up thread-specific storageYesMedium
CON31-CDo not destroy a mutex while it is lockedYesMedium
CON32-CPrevent data races when accessing bit-fields from multiple threadsNoMedium
CON33-CAvoid race conditions when using library functionsYesMedium
CON34-CDeclare objects shared between threads with appropriate storage durationsNoMedium
CON35-CAvoid deadlock by locking in a predefined orderNoLow
CON36-CWrap functions that can spuriously wake up in a loopYesLow
CON37-CDo not call signal() in a multithreaded programYesLow
CON38-CPreserve thread safety and liveness when using condition variablesYesLow
CON39-CDo not join or detach a thread that was previously joined or detachedYesLow
CON40-CDo not refer to an atomic variable twice in an expressionYesMedium
CON41-CWrap functions that can fail spuriously in a loopYesLow
CON43-CDo not allow data races in multithreaded codeNoMedium
CON50-CPPDo not destroy a mutex while it is lockedYesMedium
CON51-CPPEnsure actively held locks are released on exceptional conditionsYesLow
CON52-CPPPrevent data races when accessing bit-fields from multiple threadsYesMedium
CON53-CPPAvoid deadlock by locking in a predefined orderNoLow
CON54-CPPWrap functions that can spuriously wake up in a loopYesMedium
CON55-CPPPreserve thread safety and liveness when using condition variablesYesLow
CON56-CPPDo not speculatively lock a non-recursive mutex that is already owned by the calling threadYesLow
CPP_A000Assembler instructions only use asm keywordYes
CPP_A001Assembly language shall be encapsulated and isolated.Yes
CPP_A004Parameter of assignment operator is a constant referenceYes
CPP_A005Move and copy assignment operators shall either move or respectively copy base classes and data members of a class, without any side effectsYes
CPP_A006The asm declaration shall not be used.Yes
CPP_A007Assembler instructions shall only be introduced using the asm declaration.Yes
CPP_A008Assembly Language Code Usage not DocumentedYes
CPP_A009User-defined copy and move assignment operators should use user-defined no-throw swap function.Yes
CPP_A010Move constructor shall not initialize its class members and base classes using copy semantics.Yes
CPP_A011A copy assignment and a move assignment operators shall handle self-assignment.Yes
CPP_A012Copy and move constructors and copy assignment and move assignment operators shall be declared protected or defined "=delete" in base class.Yes
CPP_A013Assignment operators should be declared with the ref-qualifier &.Yes
CPP_A014The semantic equivalence between a binary operator and its assignment operator form shall be preservedYes
CPP_A015An assignment operator shall return a reference to "this"Yes
CPP_A016In a class template with a dependent base, any name that may be found in that dependent base shall be referred to using a qualified-id or this->Yes
CPP_A017A template should check if a specific template argument is suitable for this templateYes
CPP_AO000Assignment operators shall not be used in sub-expressionsYes
CPP_B000Bool, Unsigned, or Signed Bit-fieldsYes
CPP_B001( Fuzzy parser ) Bit-fields shall only be declared with an appropriate typeYes
CPP_B002Enum Bit-fieldsYes
CPP_B003The underlying bit representations of floating-point values shall not be usedYes
CPP_B004( Fuzzy parser ) Named bit-fields with signed integer type shall have a length of more than one bit.Yes
CPP_B005( Fuzzy parser ) Single-bit named bit fields shall not be of a signed typeYes
CPP_B006Bit-field LengthYes
CPP_C000Commented Out CodeYes
CPP_C001Line-splicing shall not be used in // commentsYes
CPP_C002No Nested CommentsYes
CPP_C003Only use /* commentsYes
CPP_C004Parameter of copy constructor is a constant referenceYes
CPP_C005Members in function-try-blocks in constructors or destructorsYes
CPP_C006Explicitly call all immediate and virtual base classesYes
CPP_C007A copy constructor shall be declared when there is a template constructor with a single parameter that is a generic parameterYes
CPP_C008A copy constructor shall only initialize its base classes and the non-static members of the class of which it is a memberYes
CPP_C009Explicit ConstructorsYes
CPP_C010Incomplete constructor initialization listYes
CPP_C011An object's dynamic type shall not be used from the body of its constructor or destructorYes
CPP_C012Virtual Function Call In ConstructorYes
CPP_C013The statement forming the body of a switch, while, do ... while or for statement shall be a compound statementYes
CPP_C014Dangling ElseYes
CPP_C015A for loop shall contain a single loop-counter which shall not have floating-point typeYes
CPP_C016An if ( condition ) construct shall be followed by a compound statement. The else keyword shall be followed by either a compound statement, or another if statementYes
CPP_C017The body of an iteration-statement or a selection-statement shall be a compound-statement Yes
CPP_C018Any label referenced by a goto statement shall be declared in the same block, or in a block enclosing the goto statementYes
CPP_C019A loop-control-variable other than the loop-counter shall not be modified within condition or expressionYes
CPP_C020If loop-counter is not modified by -- or ++, then, within condition, the loop-counter shall only be used as an operand to <=, <, > or >=Yes
CPP_C021The loop-counter shall be modified by one of: --, ++, -= n, or += n; where n remains constant for the duration of the loopYes
CPP_C022The loop-counter shall not be modified within condition or statementYes
CPP_C023The goto statement shall jump to a label declared later in the same function bodyYes
CPP_C024No Continue StatementsYes
CPP_C025Goto StatementsYes
CPP_C026 There should be no more than one break or goto statement used to terminate any iteration statementYes
CPP_C027Member data in non-POD class types shall be privateYes
CPP_C028A null statement shall only occur on a line by itselfYes
CPP_C029Single exit point at endYes
CPP_C030A switch-label shall only be used when the most closely-enclosing compound statement is the body of a switch statementYes
CPP_C031Switch Has DefaultYes
CPP_C032 Every switch statement shall have at least two switch-clausesYes
CPP_C033An unconditional throw or break statement shall terminate every non-empty switch-clauseYes
CPP_C034Unreachable CodeYes
CPP_C035No Backslash at End of CommentYes
CPP_C036If statements shall not have assignments in the conditionsYes
CPP_C037DocumentationYes
CPP_C038Before preprocessing, a null statement shall only occur on a line by itself; it may be followed by a comment, provided that the first character following the null statement is a white-space characterYes
CPP_C039A switch statement shall have at least two case-clauses, distinct from the default labelYes
CPP_C040A loop-control-variable other than the loop-counter which is modified in statement shall have type boolYes
CPP_C041Do statements should not be usedYes
CPP_C042For-init-statement and expression should not perform actions other than loop-counter initialization and modificationYes
CPP_C043Checked exceptions that could be thrown from a function shall be specified together with the function declaration and they shall be identical in all function declarations and for all its overriders.Yes
CPP_C044Continue Statement Used in a not Well-formed For LoopYes
CPP_C046Switch Statement not Well-formedYes
CPP_C047All if and else if constructs shall be terminated with an else clauseYes
CPP_C049Class Constructor with Parameter Type std::initializer_listYes
CPP_C050A for-loop that loops through all elements of the container and does not use its loop-counter shall not be usedYes
CPP_C051Constructors that are not noexcept shall not be invoked before program startupYes
CPP_C052If a constructor is not noexcept and the constructor cannot finish object initialization, then it shall deallocate the object's resources and it shall throw an exceptionYes
CPP_C053Explicit Calls to Constructors of Temporary ObjectsYes
CPP_C054When a "deep copy" constructor is not implemented, comments in the class header shall describe this factYes
CPP_C055Constructors that can be used with one argument should be declared explicit.Yes
CPP_C056Move and copy constructors shall move and respectively copy base classes and data members of a class, without any side effectsYes
CPP_CF000The condition of a switch statement shall not have bool typeYes
CPP_CF001All cases in a switch statement shall have a break or it shall be well commentedYes
CPP_CF002Switch statements should have a default caseYes
CPP_CF003Switch label unstructuredYes
CPP_CF004The std::terminate() function shall not be called implicitlyYes
CPP_CF005Program shall not be abruptly terminatedYes
CPP_CF006Simple Control FlowYes
CPP_CF007Loops with Fixed LimitsYes
CPP_CM000Comments shall precede code being commented and shall align with code they representYes
CPP_CM001Each function shall end with a commentYes
CPP_CM002Timing delays shall be preceded by comments explaining the delayYes
CPP_CM003Class headers shall include a short description for every member function declaration and a comment for every data member declaredYes
CPP_CT_BUGPRONE_ASSERT_SIDE_EFFECTAssert Side EffectYesHigh
CPP_CT_BUGPRONE_BRANCH_CLONEBranch CloneYesHigh
CPP_CT_BUGPRONE_COPY_CONSTRUCTOR_INITCopy Constructor InitYesHigh
CPP_CT_BUGPRONE_INFINITE_LOOPInfinte LoopYesHigh
CPP_CT_BUGPRONE_MACRO_REPEATED_SIDE_EFFECTSMacro Side EffectsYesHigh
CPP_CT_BUGPRONE_NOT_NULL_TERMINATED_RESULTMissing Null TerminatorYesHigh
CPP_CT_BUGPRONE_REDUNDANT_BRANCH_CONDITIONRedundant ConditionYesHigh
CPP_CT_MODERNIZE_USE_DEFAULT_MEMBER_INITDefault Member InitYes
CPP_CT_MODERNIZE_USE_EQUALS_DEFAULTDefault Member FunctionYes
CPP_CT_MODERNIZE_USE_EQUALS_DELETEDelete Member FunctionYes
CPP_CT_MODERNIZE_USE_NULLPTRNull Pointer KeywordYes
CPP_CT_READABILITY_DELETE_NULL_POINTERDelete Null PointerYesHigh
CPP_CT_READABILITY_REDUNDANT_CASTINGRedundant CastYesHigh
CPP_D000An accessible base class shall not be both virtual and non-virtual in the same hierarchyYes
CPP_D002Single DeclarationsYes
CPP_D003When an array is declared with external linkage, its size shall be stated explicitly or defined implicitly by initialisationYes
CPP_D004A u or U suffix shall be applied to all integer constants that are represented in an unsigned typeYes
CPP_D005A base class shall only be declared virtual if it is used in a diamond hierarchyYes
CPP_D006Class Derived From Virtual BasesYes
CPP_D007A compatible declaration shall be visible when an object or function with external linkage is definedYes
CPP_D008A copy assignment operator shall be declared when there is a template assignment operator with a parameter that is a generic parameterYes
CPP_D009Multiple declarations for an identifier in the same namespace shall not straddle a using-declaration for that identifierYes
CPP_D010= construct in enumerator list shall only be used on either the first item alone, or all items explicitly.Yes
CPP_D011Use the static keyword for internal linkageYes
CPP_D012An external object or function shall be declared in one and only one fileYes
CPP_D013An identifier with external linkage shall have exactly one definitionYes
CPP_D015Externals shall have the same type in the declaration and definitionYes
CPP_D017Non-static Inline FunctionsYes
CPP_D018Literal suffixes shall be upper caseYes
CPP_D019The comma operator, && operator and the || operator shall not be overloadedYes
CPP_D020The lowercase character L shall not be used in a literal suffixYes
CPP_D021Narrow and wide string literals shall not be concatenatedYes
CPP_D022Functions and objects should not be defined with external linkage if they are referenced in only one translation unitYes
CPP_D023Single-Function Global ObjectsYes
CPP_D024The restrict type qualifier shall not be usedYes
CPP_D026The register keyword shall not be usedYes
CPP_D027The unary & operator shall not be overloadedYes
CPP_D028Within an enumerator list, the value of an implicitly-specified enumeration constant shall be uniqueYes
CPP_D029Destructor Set Data Ptr to 0Yes
CPP_D031Non-Virtual Destructors in Base ClassesYes
CPP_D032Virtual Function Call In DestructorYes
CPP_D033A function shall not be declared implicitlyYes
CPP_D034Datamembers should be declared privateYes
CPP_D035Destructor of a base class shall be public virtual, public override or protected non-virtualYes
CPP_D036Volatile keyword shall not be usedYes
CPP_D037Functions shall not be declared at block scopeYes
CPP_D038When an array with external linkage is declared, its size shall be stated explicitlyYes
CPP_D039A function definition shall only be placed in a class definition if (1) the function is intended to be inlined (2) it is a member function template (3) it is a member function of a class templateYes
CPP_D040All declarations of an object or function shall have compatible typesYes
CPP_D041The One Definition RuleYes
CPP_D042If a function has internal linkage then all redeclarations shall include the static storage class specifierYes
CPP_D043Static and thread-local objects shall be constant-initializedYes
CPP_D044Declarations at Lowest ScopeYes
CPP_D045A type, object or function that is used in multiple translation units shall be declared in one and only one fileYes
CPP_D046Constexpr or const specifiers shall be used for immutable data declarationYes
CPP_D047The constexpr specifier shall be used for values that can be determined at compile timeYes
CPP_D048The auto specifier shall not be used apart from following cases: (1) to declare that a variable has the same type as return type of a function call, (2) to declare that a variable has the same type as initializer of non-fundamental type, (3) to declare parameters of a generic lambda expression, (4) to declare a function template using trailing return type syntaxYes
CPP_D049A class, structure, or enumeration shall not be declared in the definition of its typeYes
CPP_D050Enumerations shall be declared as scoped enum classesYes
CPP_D051A non-type specifier shall be placed before a type specifier in a declaration.Yes
CPP_D052Use the same identifier in definition and declaration of functions.Yes
CPP_D053Multiple Base ClassesYes
CPP_D054Virtual function declaration shall contain exactly one of the three specifiers: (1) virtual, (2) override, (3) finalYes
CPP_D055All Checks/Language Specific/C and C++/Destructors/Non-Virtual Destructors in Base ClassesYes
CPP_D056User-defined assignment operator shall not be virtualYes
CPP_D057Hierarchies should be based on interface classesYes
CPP_D058A non-POD type should be defined as classYes
CPP_D059Friend declarations shall not be used.Yes
CPP_D060If a class declares a copy or move operation, or a destructor, either via "=default", "=delete", or via a user-provided declaration, then all others of these five special member functions shall be declared as well.Yes
CPP_D061Constructors shall explicitly initialize all virtual base classes, all direct non-virtual base classes and all non-static data members.Yes
CPP_D062Both NSDMI and a non-static member initializer in a constructor shall not be used in the same type.Yes
CPP_D063If all user-defined constructors of a class initialize data members with constant values that are the same across all constructors, then data members shall be initialized using NSDMI instead.Yes
CPP_D064All constructors that are callable with a single argument of fundamental type shall be declared explicit.Yes
CPP_D065Common class initialization for non-constant members shall be done by a delegating constructor.Yes
CPP_D066If a public destructor of a class is non-virtual, then the class should be declared final.Yes
CPP_D067All class data members that are initialized by the constructor shall be initialized using member initializers.Yes
CPP_D068If the behavior of a user-defined special member function is identical to implicitly defined special member function, then it shall be defined =default or be left undefined.Yes
CPP_D069Member Data in Non-POD Class not PrivateYes
CPP_D070Template specialization shall be declared in the same file as the primary templateYes
CPP_D071All user-provided class destructors, deallocation functions, move constructors, move assignment operators and swap functions shall not exit with an exception. A noexcept exception specification shall be added to these functions as appropriateYes
CPP_D072Non-standard entities shall not be added to standard namespacesYes
CPP_D073There shall be one variable declaration per line Yes
CPP_D074An external variable shall not be set to a value where it is being declaredYes
CPP_D075Incorrect Order of InitializationYes
CPP_D076If a class requires a virtual destructor but has nothing to undo from a constructor, an empty implementation should be provided.Yes
CPP_DD000The defines, typedefs, structures, externals, globals, statics, external prototypes, and local prototypes shall be grouped by category.Yes
CPP_DD001Use of global functions and variables shall be limitedYes
CPP_DD002Globals should not be used in macrosYes
CPP_DD003There shall be a function prototype for all functionsYes
CPP_DD004Prototypes for static functions shall include the static storage classYes
CPP_DD005Any defined constants that are used as argument or return variables shall be placed in an include fileYes
CPP_DD006Initializer lists shall be written in the order in which they are declaredYes
CPP_DD007The private keyword should be used in class definitionsYes
CPP_DD008Nesting template class definitions should be avoided.Yes
CPP_DD009Assignment operators should check for self-assignmentYes
CPP_DD010The use of friend classes should be avoidedYes
CPP_DD011If the subscript operator (operator[]) is overloaded, both the const and non-const versions should be defined.Yes
CPP_DD012Layering techniques, where applicable, should be used instead of private inheritance.Yes
CPP_DD013Public Inheritance not Used in a "is-a" RelationshipYes
CPP_DD014Use the same parameter names and type qualifiers for all declarations and definitionsYes
CPP_DD015Overload allocation and deallocation functions as a pair in the same scopeYes
CPP_DD016Do not write syntactically ambiguous declarationsYes
CPP_DD017Avoid cycles during initialization of static objectsYes
CPP_DD018Obey the one-definition ruleYes
CPP_DD019Arrays shall not be partially initializedYes
CPP_DD020An element of an object shall not be initialized more than onceYes
CPP_DD021Where designated initializers are used to initialize an array object the size of the array shall be specified explicitlyYes
CPP_DD022Make sure that objects are initialized before they are usedYes
CPP_DD023Use the same form in corresponding uses of new and deleteYes
CPP_DD024Postpone variable definitions as long as possibleYes
CPP_DD025Avoid hiding inherited namesYes
CPP_DD026Never redefine an inherited non-virtual functionYes
CPP_E000A class type exception shall always be caught by referenceYes
CPP_E001There should be at least one exception handler to catch all otherwise unhandled exceptionsYes
CPP_E003Catch Const ReferencesYes
CPP_E004Destructors Not Throw ExceptionsYes
CPP_E005An empty throw (throw;) shall only be used in the compound-statement of a catch handlerYes
CPP_E006Order of Catch Blocks with Derived ClassesYes
CPP_E007An exception object should not have pointer typeYes
CPP_E008Exceptions shall be raised only after start-up and before termination of the programYes
CPP_E009Exceptions thrown shall be the type indicated by the functionYes
CPP_E011No "errno" allowedYes
CPP_E012NULL shall not be thrown explicitlyYes
CPP_E013Throw exceptions by value, not by pointerYes
CPP_E014The assignment-expression of a throw statement shall not itself cause an exception to be thrownYes
CPP_E015Expressions with type bool shall not be used as operands to built-in operators other than the assignment operator =, the logical operators &&, ||, !, the equality operators == and !=, the unary & operator, and the conditional operatorYes
CPP_E016Character OperatorsYes
CPP_E017Code Slicing Should Not OccurYes
CPP_E018Expressions with type enum or enum class shall not be used as operands to built-in and overloaded operators other than the subscript operator [ ], the assignment operator =, the equality operators == and ! =, the unary & operator, and the relational operators <, <=, >, >=Yes
CPP_E019Avoid TrigraphsYes
CPP_E020Octal constants (other than zero) and octal escape sequences (other than "\0" ) shall not be used.Yes
CPP_E021Octal and Hexadecimal SequencesYes
CPP_E022Escape sequences are standardizedYes
CPP_E023Expression uses operand of side-effect more than onceYes
CPP_E024Signed operands to modulus or division operatorYes
CPP_E025Floating Equality TestYes
CPP_E027Only those escape sequences that are defined in ISO/IEC 14882:2014 shall be usedYes
CPP_E028Hexadecimal constants should be upper caseYes
CPP_E029A "U" suffix shall be applied to all octal or hexadecimal integer literals of unsigned type.Yes
CPP_E030Concatenating String Literals of Different EncodingsYesAutomatedRequired
CPP_E031Traditional C-style casts shall not be usedYes
CPP_E032Infeasible PathsYes
CPP_E033Do not rely on the value of a moved-from objectYes
CPP_E034Limited dependence should be placed on C++ operator precedence rules in expressionsYes
CPP_E035Parameter list (possibly empty) shall be included in every lambda expressionYes
CPP_E036Specify Lambda Return TypeYes
CPP_E037Lambda expressions should not be defined inside another lambda expressionYes
CPP_E038Identical unnamed lambda expressions shall be replaced with a named function or a named lambda expressionYes
CPP_E039A lambda shall not be an operand to decltype or typeidYes
CPP_E040dynamic_cast should not be usedYes
CPP_E041reinterpret_cast shall not be usedYes
CPP_E042Operands of Logical Boolean OperatorsYes
CPP_E043The increment (++) and decrement (--) operators shall not be mixed with other operators in an expressionYes
CPP_E044Each operand of the ! operator, the logical && or the logical || operators shall have type boolYes
CPP_E045Evaluation of the operand to the sizeof operator shall not contain side effectsYes
CPP_E046The right hand operand of a shift operator shall lie between zero and one less than the width in bits of the underlying type of the left hand operand.Yes
CPP_E047The ternary conditional operator shall not be used as a sub-expressionYes
CPP_E048Each expression statement and identifier declaration shall be placed on a separate lineYes
CPP_E049The comma operator shall not be used.Yes
CPP_E050AEvaluation of the operand to the typeid operator shall not contain side effectsYes
CPP_E050BThe right hand operand of the integer division or remainder operators shall not be equal to zeroYes
CPP_E051Unary Minus Operator Applied to an Expression with an Unsigned TypeYes
CPP_E052The right-hand operand of a logical && or || operator should not contain persistent side effectsYes
CPP_E053Empty ThrowYes
CPP_E054NULL ThrowYes
CPP_E055Exception ObjectYes
CPP_E056A lambda expression object shall not outlive any of its reference-captured objectsYes
CPP_E057Only instances of types derived from std::exception should be thrownYes
CPP_E058An exception object shall not be a pointerYes
CPP_E059All thrown exceptions should be uniqueYes
CPP_E060If a function exits with an exception, then before a throw, the function shall place all objects/resources that the function constructed in valid states or it shall delete themYes
CPP_E061Dynamic exception-specification shall not be usedYes
CPP_E062A class type exception shall be caught by reference or const referenceYes
CPP_E063Catch-all (ellipsis and std::exception) handlers shall be used only in (a) main, (b) task main functions, (c) in functions that are supposed to isolate independent components and (d) when calling third-party code that uses exceptions not according to AUTOSAR C++14 guidelinesYes
CPP_E064Unhandled Exceptions on Main FunctionYes
CPP_E065Condition of if statement shall be boolYes
CPP_E066Const Should be placed on the left-hand side of the comparisonYes
CPP_E067Floats shall not be tested for direct equalityYes
CPP_E068Provide a valid ordering predicateYes
CPP_E069Assignment in SubExpressionsYes
CPP_E070Boolean operatorsYes
CPP_E072Int to Float ConversionYes
CPP_E073An implicit integral conversion shall not change the signedness of the underlying typeYes
CPP_E074Operands shall not be of an inappropriate essential typeYes
CPP_E075Both operands of an operator in which the usual arithmetic conversions are performed shall have the same essential type categoryYes
CPP_E077The value of a composite expression shall not be assigned to an object with wider essential typeYes
CPP_E078The value of a composite expression shall not be cast to a different essential type category or a wider essential typeYes
CPP_E079Conversions shall not be performed between a pointer to an incomplete type and
any other type
Yes
CPP_E080A cast shall not be performed between a pointer to object type and a pointer to a different object typeYes
CPP_E081 A conversion should not be performed between a pointer to object and an integer typeYes
CPP_E082Initializer lists shall not contain persistent side effectsYes
CPP_E083The controlling expression of an if statement and the controlling expression of an iteration-statement shall have essentially Boolean typeYes
CPP_E084The macro NULL shall be the only permitted form of integer null pointer constantYes
CPP_E085The result of an assignment operator should not be usedYes
CPP_E086A loop counter shall not have essentially floating typeYes
CPP_E087Minimize castingYes
CPP_EH000Program shall not be abruptly terminatedYes
CPP_EH001The std::terminate() function shall not be called implicitlyYes
CPP_EH002Library objects shall not generate error messages directlyYes
CPP_EH003Destructors should not throw exceptionsYes
CPP_EH004Exceptions should be caught only by referenceYes
CPP_EH005A declaration of non-throwing function shall contain noexcept specificationYes
CPP_EH006If a function is declared to be noexcept, noexcept(true) or noexcept(<truecondition>), then it shall not exit with an exceptionYes
CPP_EH007Each exception explicitly thrown in the code shall have a handler of a compatible type in all call paths that could lead to that pointYes
CPP_EH008Exceptions thrown across execution boundariesYes
CPP_EH009New Method Throwing an ExceptionYes
CPP_EH010Use Assertion StatementsYes
CPP_EH011Catch exceptions by lvalue referenceYes
CPP_F000All prototype parameters must have an identifier.Yes
CPP_F001All class templates, function templates, class template member functions and class template static members shall be instantiated at least onceYes
CPP_F002Const member functions shall not return non-const pointers or references to class-dataYes
CPP_F003Unused FunctionsYes
CPP_F004Functions with no parameters need explicit void keywordYes
CPP_F005Declare functions at file scopeYes
CPP_F006A Function identifier shall either be used to call the function or it shall be preceded by &Yes
CPP_F007Functions must not return objects by value.Yes
CPP_F008Functions shall not be defined using the ellipsis notationYes
CPP_F009Use Named Parameters and Prototype FormYes
CPP_F010Functions shall not be declared implicitlyYes
CPP_F011Inline functions defined in the class bodyYes
CPP_F012The identifier main shall not be used for a function other than the global function mainYes
CPP_F013Member functions shall not return non-const handles to class-dataYes
CPP_F014If a member function can be made static then it shall be made static, otherwise if it can be made const then it shall be made constYes
CPP_F015Missing parameter name in function declarationsYes
CPP_F016variable numbers of arguments shall not be used.Yes
CPP_F017Overloaded function templates shall not be explicitly specializedYes
CPP_F018Parameters in an overriding virtual function shall either use the same default arguments as the function they override, or else shall not specify any default arguments.Yes
CPP_F019A pointer or reference parameter in a function shall be declared as pointer to const or reference to const if the corresponding object is not modifiedYes
CPP_F020use the same identifier in definition and declaration of functions.Yes
CPP_F021The features of <stdarg.h> shall not be usedYes
CPP_F022Objects should not be passed by referenceYes
CPP_F023A function parameter should not be modifiedYes
CPP_F024The value returned by a function shall be usedYes
CPP_F025All functions with void return type shall have external side effect(s)Yes
CPP_F026Every function defined in an anonymous namespace, or static function with internal linkage, or private member function shall be usedYes
CPP_F027There shall be no unused named parameters in non-virtual functionsYes
CPP_F028There shall be no unused named parameters in the set of parameters for a virtual function and all the functions that override itYes
CPP_F029operator "new" and operator "delete" shall be defined togetherYes
CPP_F030If a project has a sized or unsized version of operator "delete" globally defined, then both sized and unsized versions shall be definedYes
CPP_F031A function shall not return a reference or a pointer to an automatic variable (including parameters), defined within the function.Yes
CPP_F032A function shall not return a reference or a pointer to a parameter that is passed by reference to const.Yes
CPP_F033Always return a value in non-void functionsYes
CPP_F034Trivial accessor and mutator functions should be inlined.Yes
CPP_F035Non-virtual public or protected member functions shall not be redefined in derived classesYes
CPP_F037Time Handling Functions of <ctime>Yes
CPP_F038_ACheck Parameters and Return Values - Ignored Return ValuesYes
CPP_F039A function that contains "forwarding reference" as its argument shall not be overloadedYes
CPP_F040A virtual function shall only be overridden by a pure virtual function if it is itself declared as pure virtualYes
CPP_F041Member functions shall not return non-const raw pointers or references to private or protected data owned by the classYes
CPP_F042If two opposite operators are defined, one shall be defined in terms of the otherYes
CPP_F043Comparison operators shall be non-member functions with identical parameter types and noexceptYes
CPP_F044Overloaded Function Not Visible From Where it is CalledYes
CPP_F045Virtual functions shall not be introduced in a final classYes
CPP_F046Predicate Function Objects Copied IncorrectlyYes
CPP_F047A template constructor shall not participate in overload resolution for a single argument of the enclosing class typeYes
CPP_F048A non-member generic operator shall only be declared in a namespace that does not contain class (struct) type, enum type or union type declarationsYes
CPP_F049Explicit specializations of function templates shall not be usedYes
CPP_F050The noexcept specification of a function shall either be identical across all translation units, or identical or more restrictive between a virtual member function and an overriderYes
CPP_F051A function should be inlined only if it has one or two lines of codeYes
CPP_F052The function gets() should not be usedYes
CPP_F053Every function shall have an explicitly declared return type.Yes
CPP_F054Boolean functions shall explicitly return true or falseYes
CPP_F055The default parameter list, when redeclaring or overriding methods, should be kept constantYes
CPP_F056Each function shall contain a prologueYes
CPP_F057Function prologue shall be in header or sourceYes
CPP_F058Function prologue shall contain certain specific informationYes
CPP_F059Variable-length argument lists should not be usedYes
CPP_F060A method that does not change the visible properties of a class shall be declared constYes
CPP_F061The type of the return and all method arguments (even type void) shall be specified when defining a methodYes
CPP_F062When overloading standardized operators (e.g., a += b, a-=b etc.), the resulting behavior should remain consistent with the expected outcome of the operator.Yes
CPP_F063Member function arguments should not share the same name as class state variablesYes
CPP_F064Member functions should always be declared const unless they modify state variablesYes
CPP_F065Any parameter not modified by a method should be passed to the method as a const.Yes
CPP_F066Tail-Call OptimizationYes
CPP_F067Functions declared with the [[noreturn]] attribute shall not returnYes
CPP_F069A signal handler must be a plain old functionYes
CPP_F070Consider alternatives to virtual functionsYes
CPP_H001The backslash character should not occur in a header file nameYes
CPP_H002The ', ", /* or // characters shall not occur in a header file nameYes
CPP_H003Definitions in Header FilesYes
CPP_H004There shall be no unnamed namespaces in header files.Yes
CPP_H005Objects or functions with external linkage shall be declared in a header fileYes
CPP_H006It shall be possible to include any header file in multiple translation units without violating the One Definition RuleYes
CPP_H007Unnecessary #IncludesYes
CPP_H008using-directives and using-declarations (excluding class scope or function scope using-declarations) shall not be used in header files.Yes
CPP_H009Header files, that are defined locally in the project, shall have a file name extension of one of: ".h", ".hpp" or ".hxx"Yes
CPP_H010Header File NameYes
CPP_H011Absolute path names shall not be used for header filesYes
CPP_H012All references to header files shall be listed one per lineYes
CPP_H013Names of private header files should not be identical to names of library header filesYes
CPP_H014All public header files shall be capable of being included by a C++ file as well as a C fileYes
CPP_H016If prototypes, typedefs, macros, structure definitions, or enums are needed in multiple modules, they shall be placed in header filesYes
CPP_H017C++ version of the header file should be usedYes
CPP_H018When including C Standard Library header files, C++ Standard Library header files without a '.h' appended should be usedYes
CPP_H019Forward referencing should be used, when appropriate, over direct inclusion when documenting dependencies within a header file.Yes
CPP_H020The standard header file <tgmath.h> shall not be usedYes
CPP_H021The standard header file <setjmp.h> shall not be usedYes
CPP_I000A class, union or enum name (including qualification, if any) shall be a unique identifierYes
CPP_I001Different identifiers shall be typographically unambiguousYes
CPP_I002External identifiers shall be distinctYes
CPP_I003Identifiers that define objects or functions with external linkage shall be uniqueYes
CPP_I005Identifier name reuseYes
CPP_I006Identifiers shall be distinct from macro namesYes
CPP_I007Identifiers declared in the same scope and name space shall be distinctYes
CPP_I008Identifiers that define objects or functions with internal linkage should be uniqueYes
CPP_I009Macro identifiers shall be distinctYes
CPP_I010The identifier name of a non-member object or function with static storage duration should not be reusedYes
CPP_I011Identifier name significanceYes
CPP_I012Static name reuseYes
CPP_I013A tag name shall be a unique identifierYes
CPP_I014A typedef name shall be a unique identifier.Yes
CPP_I015No identifier in one name space should have the same spelling as an identifier in another name space.Yes
CPP_I016Reserved Identifiers or MacrosYes
CPP_I017Shadowed IdentifiersYes
CPP_I018A class or enumeration name shall not be hidden by a variable, function or enumerator declaration in the same scopeYes
CPP_I019The identifier name of a non-member object with static storage duration or static function shall not be reused within a namespaceYes
CPP_I020An identifier name of a function with static storage duration or a non-member object with external or internal linkage should not be reusedYes
CPP_I021Universal character names shall be used only inside character or string literalsYes
CPP_I022Similiar Entity Names within Multiple InheritanceYes
CPP_I023Uppercase 'O' shall not be used as an identifierYes
CPP_I024Lowercase 'l' shall not be used as an identifierYes
CPP_I025The using namespace directive should be used only at the method or function scope.Yes
CPP_L000Calls to COTS library functions that might throw an exception must be enclosed in a try block.Yes
CPP_L001The C library shall not be usedYes
CPP_L002The signal handling facilities of <csignal> shall not be usedYes
CPP_L003The stream input/output library <cstdio> shall not be usedYes
CPP_L004<cstdlib> Library FunctionsYes
CPP_L005Avoid atof, atoi, atol, and atoll from <cstdlib> or <stdlib.h>Yes
CPP_L006Unbounded Functions of <cstring>Yes
CPP_L007Avoid using the library <ctime>Yes
CPP_L008No "errno" allowedYes
CPP_L009No offsetof allowedYes
CPP_L010The setjmp macro and the longjmp function shall not be usedYes
CPP_L011Signal.h should not be usedYes
CPP_L012Standard Library Function NamesYes
CPP_L013Avoid including stdio.hYes
CPP_L014Library stdlib.h - avoid: abort, exit, getenv and systemYes
CPP_L015Guarantee that library functions do not overflowYes
CPP_L016The library <time.h> shall not be usedYes
CPP_L017Inputs from independent components shall be validatedYes
CPP_L018Ensure your random number generator is properly seededYes
CPP_L019Random number engines shall not be default-initializedYes
CPP_L020Do not unlock or destroy another POSIX thread's mutexYes
CPP_L021An iterator shall not be implicitly converted to const_iteratorYes
CPP_L022An argument to std::forward shall not be subsequently usedYes
CPP_L023The std::move shall not be used on objects declared const or const&Yes
CPP_L024Forwarding values to other functions shall be done via: (1) std::move if the value is an rvalue reference, (2) std::forward if the value is forwarding referenceYes
CPP_L025The std::bind shall not be usedYes
CPP_L026Alternate input and output operations on a file stream shall not be used without an intervening flush or positioning callYes
CPP_L027All std::hash specializations for user-defined types shall have a noexcept function call operatorYes
CPP_L028The std::auto_ptr type shall not be usedYes
CPP_L029Library <clocale> (locale.h)Yes
CPP_L030Avoid deadlock with POSIX threads by locking in predefined orderYes
CPP_L031Evaluation of the operand to the typeid operator shall not contain side effects.Yes
CPP_L033Reserved Builtin MacrosYes
CPP_L034Use of the iostream library is preferred over stdio.hYes
CPP_M000Dynamic heap memory allocationYes
CPP_M001The form of the delete expression shall match the form of the new expression used to allocate the memoryYes
CPP_M002Non-placement new or delete expressions shall not be usedYes
CPP_M003Bitwise operations and operations that assume data representation in memory shall not be performed on objects.Yes
CPP_M004Moved-from object shall not be read-accessed.Yes
CPP_M005Uninitialized Memory ReadYes
CPP_M006Functions malloc, calloc, realloc and free shall not be usedYes
CPP_M007When reading strings a maximum field width should be specifiedYes
CPP_M008Dynamically allocated memory shall be set to some value prior to its use as an rvalue or in a testYes
CPP_M009Memory that has been freed shall not be referencedYes
CPP_M010The new[] and delete[] operators shall be used for the allocation and deallocation of memory resourcesYes
CPP_M011The delete[] operator shall be used to deallocate arrays that have been allocated with the new[] operatorYes
CPP_M012The delete[] operator shall be called in the destructor for all member pointers in an object that are pointing to memory that was dynamically allocated by that objectYes
CPP_M013Users shall provide a copy constructor, destructor and assignment operator for a class that uses dynamic memory allocationYes
CPP_M014The operator new should be called with the nothrow option.Yes
CPP_M015When overloading the new[] operator, a corresponding delete[] operator should be provided.Yes
CPP_M016Overloaded new operator should not hide the global new operatorYes
CPP_M017All local allocations made in a method, other than the destructor, should be deallocated prior to exiting the method.Yes
CPP_M018Dynamic Memory Usage on Realtime PhaseYes
CPP_M019No Dynamic Memory AllocationYes
CPP_M020Properly pair allocation and deallocation functionsYes
CPP_M021Declare objects shared between POSIX threads with appropriate storage durationsYes
CPP_N000Naming Convention: ClassesYes
CPP_N001Naming Convention: EnumeratorYes
CPP_N002Naming Convention: EnumsYes
CPP_N003Naming Convention: FilesYes
CPP_N004Naming Convention: FunctionsYes
CPP_N005Naming Convention: MacrosYes
CPP_N006Naming Convention: NamespacesYes
CPP_N007Naming Convention: ParametersYes
CPP_N008Naming Convention: StructsYes
CPP_N009Naming Convention: TypedefsYes
CPP_N010Naming Convention: UnionsYes
CPP_N011Naming Convention: VariablesYes
CPP_N012Only those characters specified in the C++ Language Standard basic source character set shall be used in the source codeYes
CPP_N013Naming Convention: Header File NamesYes
CPP_N014Naming Convention: Implementation File NamesYes
CPP_N015Implementation files, that are defined locally in the project, should have a file name extension of ".cpp"Yes
CPP_N016User defined suffixes of the user defined literal operators shall start with underscore followed by one or more lettersYes
CPP_N017Digit sequences separators ' shall only be used as follows: (1) for decimal, every 3 digits, (2) for hexadecimal, every 2 digits, (3) for binary, every 4 digitsYes
CPP_N018All macros shall be fully capitalizedYes
CPP_N019 Function and variable names shall not be fully capitalizedYes
CPP_P000No more than 2 levels of pointer indirectionYes
CPP_P001Hide Implementation of Pointers Not DereferencedYes
CPP_P002Pointer initialization must use 0, not NULL.Yes
CPP_P003Pointer function parameters must be tested for equality to 0 before accessing the data being pointed toYes
CPP_P004Pointers Must Be InitializedYes
CPP_P005Arguments to a function-like macro shall not contain tokens that look like preprocessing directivesYes
CPP_P006std::make_unique shall be used to construct objects owned by std::unique_ptrYes
CPP_P007A std::unique_ptr shall be used over std::shared_ptr if ownership sharing is not requiredYes
CPP_P008Do Not Use #defineYes
CPP_P009In the definition of a function-like macro, each instance of a parameter shall be enclosed in parentheses, unless it is used as the operand of # or ##Yes
CPP_P011Ifndef Wrappers or Pragma OnceYes
CPP_P012File Include Matching HeaderYes
CPP_P013Function-like macros shall not be definedYes
CPP_P014_ARestrict Pointer Usage - Multiple DereferencesYes
CPP_P014_BRestrict Pointer Usage - OtherYes
CPP_P015Inactive CodeYes
CPP_P017#include directives in a file shall only be preceded by other preprocessor directives or commentsYes
CPP_P018A macro shall not be defined with the same name as a keywordYes
CPP_P019Macros in BlocksYes
CPP_P020C++ macros shall only be used for include guards, type qualifiers, or storage class specifiersYes
CPP_P021Before dereferencing a pointer, compare it with NULLYes
CPP_P022The pre-processor shall only be used for file inclusion and include guardsYes
CPP_P023Reserved identifiers, macros and functions in the standard library shall not be defined, redefined or undefinedYes
CPP_P024The address of an object with automatic storage shall not be assigned to another object that may persist after the first object has ceased to exist.Yes
CPP_P026avoid #undefYes
CPP_P028A smart pointer shall only be used as a parameter type if it expresses lifetime semanticsYes
CPP_P029A project should not contain unused macro declarationsYes
CPP_P030Invalid Use of std::shared_ptrYes
CPP_P031Invalid Use of std::unique_ptrYes
CPP_P032Cyclic Structure of std::shared_ptrYes
CPP_P033For pointer declarations, the asterisk shall be placed with the variableYes
CPP_P034Const Member Function Returning Non-Const Pointer or ReferenceYes
CPP_P035std::make_shared shall be used to construct objects owned by std::shared_ptrYes
CPP_P036A std::shared_ptr shall be used to represent shared ownershipYes
CPP_P037A std::unique_ptr shall be used to represent exclusive ownershipYes
CPP_P038An already-owned pointer value shall not be stored in an unrelated smart pointerYes
CPP_P039String literals shall not be assigned to non-constant pointersYes
CPP_P040Only nullptr literal shall be used as the null-pointer-constantYes
CPP_P041Subtraction between pointers shall only be applied to pointers that address elements of the same arrayYes
CPP_P042Pointer arithmetic shall not be used with pointers to non-final classesYes
CPP_P043>, >=, <, <= shall not be applied to objects of pointer type, except where they point to the same arrayYes
CPP_P044Deleting Pointers to Incomplete Class TypesYes
CPP_P045Array indexing over pointer arithmeticYes
CPP_P046A pointer pointing to an element of an array of objects shall not be passed to a smart pointer of single object typeYes
CPP_P047A cast shall not convert a pointer to a function to any other pointer type, including a pointer to function typeYes
CPP_P048A pointer to member virtual function shall only be tested for equality with null-pointer-constantYes
CPP_P049A pointer operand and any pointer resulting from pointer arithmetic using that operand shall both address elements of the same arrayYes
CPP_P050Literal zero (0) shall not be used as the null-pointer-constant.Yes
CPP_P051Pointer to Integer CastYes
CPP_P052A parameter shall be passed by reference if it can't be NULLYes
CPP_P053A pointer to member shall not access non-existent class membersYes
CPP_P054References should be used instead of pointers when possible.Yes
CPP_P055For pointer declarations, the placement of the * shall be consistentYes
CPP_P056Pointer functions shall return a valid pointer on success and a zero pointer on failureYes
CPP_P057A pointer to dynamic memory that is declared and allocated locally should be declared as an auto_ptr. Yes
CPP_P058Store newed objects in smart pointers in standalone statementsYes
CPP_P060Prefer pass-by-reference-to-const to pass by valueYes
CPP_P061Shared Pointer CaptureYes
CPP_PR000#define and #undef shall not be used on a reserved identifier or reserved macro nameYes
CPP_PR001Include guards shall be providedYes
CPP_PR002Constants defined by #define shall be explicitly declared with uppercase suffixesYes
CPP_PR003Macros shall not be used to change language syntaxYes
CPP_PR004Limit Preprocessor UsageYes
CPP_PR005#include directives should only be preceded by preprocessor directives or commentsYes
CPP_PR006There shall be at most one occurrence of the # or ## operators in a single macro definitionYes
CPP_PR007The defined preprocessor operator shall only be used in one of the two standard formsYes
CPP_PR021The names of standard library macros and objects shall not be reusedYes
CPP_PR030The #pragma directive shall not be usedYes
CPP_PR031#error directive shall not be usedYes
CPP_PR032The # and ## operators should not be usedYes
CPP_PR033The macro offsetof shall not be usedYes
CPP_PR034There shall be no unused include directives (slow)Yes
CPP_PR036Invalid Preprocessor DirectivesYes
CPP_PR037Undefined macro identifiers shall not be used in #if or #elif preprocessor directives, except as operands to the defined operatorYes
CPP_PR038In the definition of a function-like macro, each instance of a parameter shall be enclosed in parentheses, unless it is used as the operand of # or ##Yes
CPP_PR039Function-like Macro Containing Preprocessing DirectivesYes
CPP_PR040#include Directives Not Grouped TogetherYes
CPP_PR041Incorrect Use of Pre-processorYes
CPP_S000no unionsYes
CPP_S001Flexible array members shall not be declaredYes
CPP_S002Incorrect Initializer ListsYes
CPP_S003A type defined as struct shall: (1) provide only public data members, (2) not provide any special member functions or methods, (3) not be a base of another struct or class, (4) not inherit from another struct or classYes
CPP_S004Unions Shall not be UsedYes
CPP_SA_DANGLING_POINTERSDangling PointerYesHigh
CPP_SA_DEAD_STORESDead StoresYes
CPP_SA_DIV_ZERODivision by ZeroYesHigh
CPP_SA_LEAKSMemory LeakYesHigh
CPP_SA_NULL_PTRNull Pointer DereferenceYesHigh
CPP_SA_STACK_ADDRESS_ESCAPEStack Address EscapeYesHigh
CPP_SA_UNDEFINED_CALLUndefined CallYesHigh
CPP_SA_UNINITIALIZEDUninitialized ValueYesHigh
CPP_SA_VIRTUAL_CALLSVirtual CallYesHigh
CPP_ST001Not more than one space should precede a ";" with the exception of the null statementYes
CPP_ST002Equal signs should be aligned when they occur in a series of assignment operatorsYes
CPP_ST003Placement of braces for functions shall adhere to one of the following formats and shall be consistentYes
CPP_ST004Code between the beginning and ending braces of a function shall start with one level of indentationYes
CPP_ST005Enum lists should not contain a trailing commaYes
CPP_ST006No line of code should extend beyond column 80Yes
CPP_ST007Declarations shall not be made within an individual block but shall be placed at the function level or at the module level.Yes
CPP_ST008Blank lines should be used to separate distinct algorithmic partsYes
CPP_ST009Parentheses should be used in lengthy logical and arithmetic expressions for clarity.Yes
CPP_ST010Items should be logically groupedYes
CPP_ST011Inline functions should be used instead of macrosYes
CPP_ST012Names that differ in case only or that look similar should not be used.Yes
CPP_ST013Switch statements should be used instead of deeply nested else-ifs when testing a variable for multiple valuesYes
CPP_ST014No line of code should extend beyond 80 charactersYes
CPP_ST015Incrementing and decrementing control variables in loopsYes
CPP_ST016Calls to free should have an if test around them if it is uncertain that the pointer has been properly allocated.Yes
CPP_ST017White space shall not be used in the following placesYes
CPP_ST018Continuation lines shall be indented at least one level from the line being continuedYes
CPP_ST019Statements under case labels shall be indented one levelYes
CPP_ST020For the if-else, while, do, and for control structure, the statement(s) shall be indented one levelYes
CPP_ST021Placement of braces for constructs shall be consistent within a moduleYes
CPP_ST022Boolean expressions involving non-boolean values should always use an explicit test for equality or non-equality.Yes
CPP_ST023At least one blank line shall be placed before commentsYes
CPP_ST024Functions shall have at least one blank line between themYes
CPP_ST025Each area of declarations shall have at least one blank line before and after itYes
CPP_ST026Class naming conventionsYes
CPP_ST027Naming conventions for class data members vs. member function internal dataYes
CPP_ST028Data type naming conventionsYes
CPP_ST029Immutable data naming conventionsYes
CPP_ST030Class design should include the following formatYes
CPP_ST031Separate lines should be used for each member declarationYes
CPP_ST032Indentation shall be at least three spaces, and consistent across modulesYes
CPP_ST033Short FunctionsYes
CPP_T000Typedefs that indicate size and signedness should be used in place of the basic numerical typesYes
CPP_T001Arguments to character-handling functions shall be representable as an unsigned charYes
CPP_T002The std::vector<bool> specialization shall not be usedYes
CPP_T003There should be no unused type declarationsYes
CPP_T004Type long double shall not be usedYes
CPP_T005Type wchar_t shall not be usedYes
CPP_T006The types used for an object, a function return type, or a function parameter shall be token-for-token identical in all declarations and re-declarationsYes
CPP_T007A cvalue expression shall not be implicitly converted to a different underlying typeYes
CPP_T008An implicit integral conversion shall not change the signedness of the underlying typeYes
CPP_T009There shall be no implicit floating-integral conversionsYes
CPP_T010An implicit integral or floating-point conversion shall not reduce the size of the underlying typeYes
CPP_T011There shall be no explicit floating-integral conversions of a cvalue expressionYes
CPP_T012An explicit integral or floating-point conversion shall not increase the size of the underlying type of a cvalue expressionYes
CPP_T013An explicit integral conversion shall not change the signedness of the underlying type of a cvalue expressionYes
CPP_T014If the bitwise operators ~ and << are applied to an operand with an underlying type of unsigned char or unsigned short, the result shall be immediately cast to the underlying type of the operandYes
CPP_T015The plain char type shall only be used for the storage and use of character valuesYes
CPP_T016Signed char and unsigned char type shall only be used for the storage and use of numeric valuesYes
CPP_T017The first operand of a conditional-operator shall have type boolYes
CPP_T018Bitwise operators shall only be applied to operands of unsigned underlying typeYes
CPP_T019C-style ArrayYes
CPP_T020Casts from a base class to a derived class should not be performed on polymorphic typesYes
CPP_T021A cast shall not remove any const or volatile qualification from the type of a pointer or referenceYes
CPP_T022An object with integer type or pointer to void type shall not be converted to an object with pointer type.Yes
CPP_T023Array to Pointer DecayYes
CPP_T024NULL shall not be used as an integer valueYes
CPP_T025CV-qualifiers shall be placed on the right hand side of the type that is a typedef or a using nameYes
CPP_T026The typedef specifier shall not be usedYes
CPP_T027An expression with enum underlying type shall only have values corresponding to the enumerators of the enumerationYes
CPP_T028Enumeration underlying base type shall be explicitly definedYes
CPP_T029In an enumeration, either (1) none, (2) the first or (3) all enumerators shall be initializedYes
CPP_T030When declaring function templates, the trailing return type syntax shall be used if the return type depends on the type of parameters.Yes
CPP_T031Common ways of passing parameters should be used.Yes
CPP_T032Multiple output values from a function should be returned as a struct or tuple.Yes
CPP_T033"consume" parameters declared as X && shall always be moved from.Yes
CPP_T034"forward" parameters declared as T && shall always be forwarded.Yes
CPP_T035"in" parameters for "cheap to copy" types shall be passed by value.Yes
CPP_T036Output parameters shall not be used.Yes
CPP_T037"in-out" parameters declared as T & shall be modified.Yes
CPP_T038Fixed Width IntegersYes
CPP_T039Non-constant operands to a binary bitwise operator shall have the same underlying typeYes
CPP_T040User defined literals operators shall only perform conversion of passed parametersYes
CPP_T041A binary arithmetic operator and a bitwise operator shall return a "prvalue"Yes
CPP_T042A relational operator shall return a boolean valueYes
CPP_T043If "operator[]" is to be overloaded with a non-const version, const version shall also be implementedYes
CPP_T044Undocumented Use of Floating-point ArithmeticYes
CPP_T045Undocumented Use of Scaled-integer or Fixed-point ArithmeticYes
CPP_T046Assigning Object to an Overlapping ObjectYes
CPP_T047Data types used for interfacingYes
CPP_T048All user-defined conversion operators shall be defined explicitYes
CPP_T049User-defined conversion operators should not be usedYes
CPP_T050Types shall be explicitly specifiedYes
CPP_T051C-style strings shall not be usedYes
CPP_T052String-to-Number Conversion HandlingYes
CPP_T053A type used as a template argument shall provide all members that are used by the templateYes
CPP_T054AAn array or container shall not be accessed beyond its range (Part A)Yes
CPP_T054BAn array or container shall not be accessed beyond its range Part BYes
CPP_T055A value should not be retrieved from a structure or union with a different type than with which it was storedYes
CPP_T056Explicit type casting shall be used when performing calculations with a mix of signed and unsigned values.Yes
CPP_T057Actual arguments shall be explicitly type cast to the appropriate typeYes
CPP_T058Simple integers shall be used to test and set booleansYes
CPP_T059Width-sensitive types should be typedef'd and placed in a header fileYes
CPP_T060Converting a pointer to integer or integer to pointerYes
CPP_T061All Checks/Language Specific/C and C++/Types/Use Const whenever possibleYes
CPP_U000Digraphs shall not be usedYes
CPP_U001Discarded return values.Yes
CPP_U002Inline Functions have more than X LOCYes
CPP_U003Unused Parameters in Non-virtual FunctionsYes
CPP_U004Unused Static GlobalsYes
CPP_U005A project should not contain unused tag declarationsYes
CPP_U006A project shall not contain unused type declarationsYes
CPP_U007Unused LabelsYes
CPP_U010Unused EntitiesYes
CPP_V000Magic NumbersYes
CPP_V001One Variable per LineYes
CPP_V002Reference Symbols Spacing, (& *)Yes
CPP_V003Declare each variable in a separate declaration statementYes
CPP_V004A project shall not contain non-volatile POD variables having only one use.Yes
CPP_V005Types or externals declared at the function level.Yes
CPP_V006A variable which is not modified shall be const qualifiedYes
CPP_V007Unused Local VariablesYes
CPP_V008Unused Static GlobalYes
CPP_V009Using-directives shall not be used.Yes
CPP_V010Variables should be commentedYes
CPP_V011All variables shall have a defined value before they are usedYes
CPP_V012Explicit VirtualYes
CPP_V013There shall be no more than one definition of each virtual function on each path through the inheritance hierarchyYes
CPP_V014A virtual function shall only be overridden by a pure virtual function if it is itself declared as pure virtualYes
CPP_V015There shall be no unused parameters (named or unnamed) in the set of parameters for a virtual function and all the functions that override itYes
CPP_V017A project shall not contain instances of non-volatile variables being given values that are not subsequently usedYes
CPP_V018Auto VariableYes
CPP_V019Initializing Variables Without Using Braced-InitializationYes
CPP_V020Class members that are not dependent on template class parameters should be defined in a separate base classYes
CPP_V021Variables should not be altered more than once in an expressionYes
CPP_V022Variables shall not be implicitly captured in a lambda expressionYes
CPP_V023Literal values shall not be used apart from type initialization, otherwise symbolic names shall be used insteadYes
CPP_V024Variables of type char shall be explicitly qualified as signed or unsigned when used to store numbersYes
CPP_V025Every variable shall be declared with a specific typeYes
CPP_V026Local variables shall be initialized when declaredYes
CPP_V027Globals in header files shall be ifdef'dYes
CPP_V028Constants should be declared as const values as opposed to #define directives.Yes
CPP_V029The const_cast operator should be used exclusively for altering the constness attribute of a variable.Yes
CPP_V030The dynamic_cast operator should be used exclusively for casting within an inheritance hierarchy.Yes
CPP_V031The static_cast operator should be used for routine cast operations not provided by const_cast and dynamic_cast. Yes
CPP_V032Use of the reinterpret_cast operator should be avoidedYes
CPP_V033Typedef'd variables in a class shall be placed in an include fileYes
CPP_V034STL containers (vector, list, map, etc.) should be used instead of C-style arrays whenever possible.Yes
CPP_V035Objects that do not outlive a function shall have automatic storage durationYes
CPP_V036Static data member initialization should be placed in the class .cpp fileYes
CPP_V037Initializer lists should be used to initialize member variables over direct assignment.Yes
CPP_V038The concept of information hiding should be implemented.Yes
CPP_V039Within an object, most instance variables should be accessed directly. Methods should be used to set variables whose values are determined by an algorithm.Yes
CPP_VF000Every class that contains virtual functions shall provide a virtual destructorYes
CPP_VF001Access levels should not be mixed (public, protected, private) when overriding virtual functions.Yes
CPP_WARN_ABSOLUTE_VALUEAbsolute Value Proper UsageYes
CPP_WARN_ABSTRACT_FINAL_CLASSAbstract Classes Should Not Be Final or SealedYes
CPP_WARN_ABSTRACT_VBASE_INITNo Useless Init for Abstract Virtual BaseYes
CPP_WARN_ADDRESS_OF_PACKED_MEMBERDo Not Take the Address of Packed MembersYes
CPP_WARN_ADDRESS_OF_TEMPORARYDo Not Take the Address of Temporary ObjectsYesHigh
CPP_WARN_AIX_COMPATIBM AIX Compatibility with Byte AlignmentYes
CPP_WARN_ALIGN_MISMATCHMatch Byte Alignment of ArgumentsYes
CPP_WARN_ALLOCADo Not Use Certain Allocation FunctionsYes
CPP_WARN_ALLOCA_WITH_ALIGN_ALIGNOFCorrect Usage of Second Argument of Certain Allocation FunctionsYes
CPP_WARN_ALWAYS_INLINE_COROUTINEAlways Inline Coroutine FunctionsYes
CPP_WARN_AMBIGUOUS_DELETEAmbiguous DeleteYes
CPP_WARN_AMBIGUOUS_ELLIPSISAmbiguous EllipsisYes
CPP_WARN_AMBIGUOUS_MACROAmbiguous MacroYes
CPP_WARN_AMBIGUOUS_MEMBER_TEMPLATEAmbiguous Member TemplateYes
CPP_WARN_AMBIGUOUS_REVERSED_OPERATORAmbiguous Reversed OperatorYes
CPP_WARN_ANALYZER_INCOMPATIBLE_PLUGINAnalyzer Incompatible PluginYes
CPP_WARN_ANON_ENUM_ENUM_CONVERSIONAnon-Enum Enum ConversionYes
CPP_WARN_ANONYMOUS_PACK_PARENSAnonymous Pack ParenthesesYes
CPP_WARN_ARC_BRIDGE_CASTS_DISALLOWED_IN_NONARCARC (Automatic Reference Counting) Bridge Casts Disallowed in Non-ARCYes
CPP_WARN_ARC_MAYBE_REPEATED_USE_OF_WEAKARC Maybe Repeated Use of WeakYes
CPP_WARN_ARC_RETAIN_CYCLESARC Retain CyclesYes
CPP_WARN_ARC_UNSAFE_RETAINED_ASSIGNARC Unsafe Retained AssignYes
CPP_WARN_ARGUMENT_OUTSIDE_RANGEArgument Outside RangeYes
CPP_WARN_ARGUMENT_UNDEFINED_BEHAVIOURArgument Undefined BehaviourYes
CPP_WARN_ARRAY_BOUNDSArray BoundsYesHigh
CPP_WARN_ARRAY_BOUNDS_POINTER_ARITHMETICArray Bounds Pointer ArithmeticYes
CPP_WARN_ARRAY_PARAMETERArray ParameterYes
CPP_WARN_ASM_OPERAND_WIDTHSAssembly Operand WidthsYes
CPP_WARN_ASSIGN_ENUMAssign EnumYes
CPP_WARN_ASSUMEDiscarded Side Effects to __assume FunctionYes
CPP_WARN_ATOMIC_ACCESSAtomic AccessYes
CPP_WARN_ATOMIC_ALIGNMENTAtomic AlignmentYes
CPP_WARN_ATOMIC_IMPLICIT_SEQ_CSTAtomic Implicitly Sequentially-ConsistentYes
CPP_WARN_ATOMIC_MEMORY_ORDERINGAtomic Memory OrderingYes
CPP_WARN_AUTO_DISABLE_VPTR_SANITIZERAuto Disable Virtual Pointer SanitizerYes
CPP_WARN_AUTO_STORAGE_CLASSAuto Storage ClassYes
CPP_WARN_AVAILABILITYAvailability AttributeYesHigh
CPP_WARN_AVR_RTLIB_LINKING_QUIRKSAVR RTLIB (Real-Time Library) Linking QuirksYes
CPP_WARN_BACKEND_PLUGINBackend PluginYes
CPP_WARN_BACKSLASH_NEWLINE_ESCAPEBackslash Newline EscapeYesHigh
CPP_WARN_BAD_FUNCTION_CASTDo Not Cast from Function Call of One Type to AnotherYes
CPP_WARN_BIND_TO_TEMPORARY_COPYBind to Temporary CopyYes
CPP_WARN_BINDING_IN_CONDITIONBinding in ConditionYes
CPP_WARN_BIT_INT_EXTENSIONBit Int ExtensionYes
CPP_WARN_BITFIELD_CONSTANT_CONVERSIONBitfield Constant ConversionYesHigh
CPP_WARN_BITFIELD_ENUM_CONVERSIONBitfield Enum ConversionYes
CPP_WARN_BITFIELD_WIDTHDo Not Exceed Bit-Field WidthYesHigh
CPP_WARN_BITWISE_CONDITIONAL_PARENTHESESBitwise Conditional ParenthesesYes
CPP_WARN_BITWISE_INSTEAD_OF_LOGICALBitwise Instead of LogicalYes
CPP_WARN_BITWISE_OP_PARENTHESESBitwise Operator ParenthesesYes
CPP_WARN_BOOL_CONVERSIONBool ConversionYesHigh
CPP_WARN_BOOL_OPERATIONBool OperationYes
CPP_WARN_BRACED_SCALAR_INITBraced Scalar InitYes
CPP_WARN_BRANCH_PROTECTIONBranch ProtectionYes
CPP_WARN_BUILTIN_ASSUME_ALIGNED_ALIGNMENTBuiltin Assume Aligned AlignmentYes
CPP_WARN_BUILTIN_MACRO_REDEFINEDBuiltin Macro RedefinedYesHigh
CPP_WARN_BUILTIN_MEMCPY_CHK_SIZEBuiltin Memcpy Check SizeYesHigh
CPP_WARN_BUILTIN_REQUIRES_HEADERBuiltin Requires HeaderYes
CPP_WARN_C2X_EXTENSIONSC2X ExtensionsYes
CPP_WARN_C11_EXTENSIONSC11 ExtensionsYes
CPP_WARN_C99_COMPATC99 CompatibilityYes
CPP_WARN_C99_DESIGNATORC99 DesignatorYes
CPP_WARN_C99_EXTENSIONSC99 ExtensionsYes
CPP_WARN_CALL_TO_PURE_VIRTUAL_FROM_CTOR_DTORCall to Pure Virtual from Constructor or DestructorYesHigh
CPP_WARN_CALLED_ONCE_PARAMETERCalled once ParameterYes
CPP_WARN_CAST_ALIGNCast AlignYes
CPP_WARN_CAST_CALLING_CONVENTIONCast Calling ConventionYes
CPP_WARN_CAST_FUNCTION_TYPECast Function TypeYes
CPP_WARN_CAST_QUALCast QualifiersYes
CPP_WARN_CAST_QUAL_UNRELATEDCast Qualifiers UnrelatedYesHigh
CPP_WARN_CHAR_SUBSCRIPTSChar SubscriptsYes
CPP_WARN_CLANG_CL_PCHClang-CL Precompiled HeadersYes
CPP_WARN_CLASS_CONVERSIONClass ConversionYesHigh
CPP_WARN_CLASS_VARARGSClass Variadic ArgumentsYes
CPP_WARN_CMSE_UNION_LEAKCMSE (Cortex-M Support for Security Extension) Union LeakYes
CPP_WARN_COMMAComma Operator MisuseYes
CPP_WARN_COMMENTComment MisuseYes
CPP_WARN_COMPARE_DISTINCT_POINTER_TYPESCompare Distinct Pointer TypesYesHigh
CPP_WARN_COMPLEX_COMPONENT_INITComplex Component InitYes
CPP_WARN_COMPOUND_TOKEN_SPLIT_BY_MACROCompound Token Split by MacroYesHigh
CPP_WARN_COMPOUND_TOKEN_SPLIT_BY_SPACECompound Token Split by SpaceYes
CPP_WARN_CONDITIONAL_TYPE_MISMATCHConditional Type MismatchYesHigh
CPP_WARN_CONDITIONAL_UNINITIALIZEDConditional UninitializedYes
CPP_WARN_CONSTANT_CONVERSIONConstant ConversionYesHigh
CPP_WARN_CONSTANT_EVALUATEDConstant EvaluatedYes
CPP_WARN_CONSTANT_LOGICAL_OPERANDConstant Logical OperandYesHigh
CPP_WARN_CONSTEXPR_NOT_CONSTConstexpr Not ConstYes
CPP_WARN_CONSUMEDConsumable AttributeYes
CPP_WARN_CONVERSIONType ConversionYes
CPP_WARN_COROUTINECoroutine Return TypeYes
CPP_WARN_COROUTINE_MISSING_UNHANDLED_EXCEPTIONCoroutine Missing Unhandled ExceptionYes
CPP_WARN_COVERED_SWITCH_DEFAULTCovered Switch DefaultYes
CPP_WARN_CPP_COMPATC++ CompatibilityYes
CPP_WARN_CPP2B_EXTENSIONSC++2B ExtensionsYes
CPP_WARN_CPP11_COMPATC++11 CompatibilityYes
CPP_WARN_CPP11_COMPAT_DEPRECATED_WRITABLE_STRINGSC++11 Compatibility Deprecated Writable StringsYesHigh
CPP_WARN_CPP11_COMPAT_RESERVED_USER_DEFINED_LITERALC++11 Compatibility Reserved User Defined LiteralYes
CPP_WARN_CPP11_EXTENSIONSC++11 ExtensionsYes
CPP_WARN_CPP11_EXTRA_SEMIC++11 Extra SemicolonYes
CPP_WARN_CPP11_INLINE_NAMESPACEC++11 Inline NamespaceYes
CPP_WARN_CPP11_LONG_LONGC++11 Long LongYes
CPP_WARN_CPP11_NARROWINGC++11 NarrowingYes
CPP_WARN_CPP14_ATTRIBUTE_EXTENSIONSC++14 Attribute ExtensionsYes
CPP_WARN_CPP14_BINARY_LITERALC++14 Binary LiteralYes
CPP_WARN_CPP14_EXTENSIONSC++14 ExtensionsYes
CPP_WARN_CPP17_ATTRIBUTE_EXTENSIONSC++17 Attribute ExtensionsYes
CPP_WARN_CPP17_COMPAT_MANGLINGC++17 Compatibility ManglingYes
CPP_WARN_CPP17_EXTENSIONSC++17 ExtensionsYes
CPP_WARN_CPP20_ATTRIBUTE_EXTENSIONSC++20 Attribute ExtensionsYes
CPP_WARN_CPP20_COMPATC++20 CompatibilityYes
CPP_WARN_CPP20_DESIGNATORC++20 DesignatorYes
CPP_WARN_CPP20_EXTENSIONSC++20 ExtensionsYes
CPP_WARN_CPP98_COMPATC++98 CompatibilityYes
CPP_WARN_CPP98_COMPAT_BIND_TO_TEMPORARY_COPYC++98 Compatibility Bind to Temporary CopyYes
CPP_WARN_CPP98_COMPAT_EXTRA_SEMIC++98 Compatibility Extra SemicolonYes
CPP_WARN_CPP98_COMPAT_LOCAL_TYPE_TEMPLATE_ARGSC++98 Compatibility Local Type Template ArgsYes
CPP_WARN_CPP98_COMPAT_PEDANTICC++98 Compatibility PedanticYes
CPP_WARN_CPP98_COMPAT_UNNAMED_TYPE_TEMPLATE_ARGSC++98 Compatibility Unnamed Type Template ArgsYes
CPP_WARN_CPP98_CPP11_COMPAT_BINARY_LITERALC++98 C++11 Compatibility Binary LiteralYes
CPP_WARN_CTAD_MAYBE_UNSUPPORTEDCTAD (Class Template Argument Deduction) Maybe UnsupportedYes
CPP_WARN_CXX_ATTRIBUTE_EXTENSIONC++ Attribute ExtensionYes
CPP_WARN_DANGLINGDangling PointersYesHigh
CPP_WARN_DANGLING_ELSEDangling ElseYes
CPP_WARN_DANGLING_FIELDDangling FieldYesHigh
CPP_WARN_DANGLING_GSLDangling Pointers Found by Guidelines Support LibraryYesHigh
CPP_WARN_DANGLING_INITIALIZER_LISTDangling Initializer ListYesHigh
CPP_WARN_DARWIN_SDK_SETTINGSDarwin SDK SettingsYes
CPP_WARN_DATE_TIMEDate and Time MacrosYes
CPP_WARN_DEALLOC_IN_CATEGORYDealloc in CategoryYes
CPP_WARN_DEBUG_COMPRESSION_UNAVAILABLEDebug Compression UnavailableYes
CPP_WARN_DECLARATION_AFTER_STATEMENTDeclaration After StatementYes
CPP_WARN_DEFAULTED_FUNCTION_DELETEDDefaulted Function DeletedYesHigh
CPP_WARN_DELEGATING_CTOR_CYCLESDelegating Constructor CyclesYesHigh
CPP_WARN_DELETE_ABSTRACT_NON_VIRTUAL_DTORDelete Abstract Non-Virtual DestructorYesHigh
CPP_WARN_DELETE_INCOMPLETEDelete IncompleteYesHigh
CPP_WARN_DELETE_NON_ABSTRACT_NON_VIRTUAL_DTORDelete Non-Abstract Non-Virtual DestructorYes
CPP_WARN_DEPRECATEDDeprecatedYes
CPP_WARN_DEPRECATED_ALTIVEC_SRC_COMPATDeprecated AltiVec Instruction Set Source CompatibilityYes
CPP_WARN_DEPRECATED_ANON_ENUM_ENUM_CONVERSIONDeprecated Anon-Enum, Enum ConversionYes
CPP_WARN_DEPRECATED_ARRAY_COMPAREDeprecated Array CompareYes
CPP_WARN_DEPRECATED_ATTRIBUTESDeprecated AttributesYes
CPP_WARN_DEPRECATED_BUILTINSDeprecated BuiltinsYesHigh
CPP_WARN_DEPRECATED_COMMA_SUBSCRIPTDeprecated Comma SubscriptYes
CPP_WARN_DEPRECATED_COPYDeprecated CopyYes
CPP_WARN_DEPRECATED_COPY_WITH_DTORDeprecated Copy with DestructorYes
CPP_WARN_DEPRECATED_COPY_WITH_USER_PROVIDED_COPYDeprecated Copy with User Provided CopyYes
CPP_WARN_DEPRECATED_COPY_WITH_USER_PROVIDED_DTORDeprecated Copy with User Provided DestructorYes
CPP_WARN_DEPRECATED_COROUTINEDeprecated CoroutineYes
CPP_WARN_DEPRECATED_DECLARATIONSDeprecated DeclarationsYesHigh
CPP_WARN_DEPRECATED_DYNAMIC_EXCEPTION_SPECDeprecated Dynamic Exception SpecYes
CPP_WARN_DEPRECATED_EXPERIMENTAL_COROUTINEDeprecated Experimental CoroutineYes
CPP_WARN_DEPRECATED_IMPLEMENTATIONSDeprecated ImplementationsYes
CPP_WARN_DEPRECATED_INCREMENT_BOOLDeprecated Increment BoolYesHigh
CPP_WARN_DEPRECATED_NON_PROTOTYPEDeprecated Non-PrototypeYesHigh
CPP_WARN_DEPRECATED_REGISTERDeprecated RegisterYesHigh
CPP_WARN_DEPRECATED_STATIC_ANALYZER_FLAGDeprecated Static Analyzer FlagYes
CPP_WARN_DEPRECATED_THIS_CAPTUREDeprecated This CaptureYes
CPP_WARN_DEPRECATED_TYPEDeprecated TypeYes
CPP_WARN_DEPRECATED_VOLATILEDeprecated VolatileYesHigh
CPP_WARN_DISABLED_MACRO_EXPANSIONDisabled Macro ExpansionYes
CPP_WARN_DIVISION_BY_ZERODivision by ZeroYesHigh
CPP_WARN_DLL_ATTRIBUTE_ON_REDECLARATIONDLL Attribute on Re-DeclarationYes
CPP_WARN_DLLEXPORT_EXPLICIT_INSTANTIATION_DECLDLLexport Explicit Instantiation DeclYes
CPP_WARN_DLLIMPORT_STATIC_FIELD_DEFDLLimport Static Field DefYes
CPP_WARN_DOCUMENTATIONDocumentation WarningsYes
CPP_WARN_DOCUMENTATION_DEPRECATED_SYNCDocumentation Deprecated SyncYes
CPP_WARN_DOCUMENTATION_HTMLDocumentation HtmlYes
CPP_WARN_DOCUMENTATION_PEDANTICDocumentation PedanticYes
CPP_WARN_DOCUMENTATION_UNKNOWN_COMMANDDocumentation Unknown CommandYes
CPP_WARN_DOLLAR_IN_IDENTIFIER_EXTENSIONDollar in Identifier ExtensionYes
CPP_WARN_DOUBLE_PROMOTIONDouble PromotionYes
CPP_WARN_DTOR_NAMEDestructor NameYes
CPP_WARN_DTOR_TYPEDEFDestructor TypedefYes
CPP_WARN_DUPLICATE_DECL_SPECIFIERDuplicate Decl SpecifierYes
CPP_WARN_DUPLICATE_ENUMDuplicate EnumYes
CPP_WARN_DUPLICATE_METHOD_ARGDuplicate Method ArgYes
CPP_WARN_DUPLICATE_METHOD_MATCHDuplicate Method MatchYes
CPP_WARN_DUPLICATE_PROTOCOLDuplicate ProtocolYes
CPP_WARN_DYNAMIC_CLASS_MEMACCESSDynamic Class Memory AccessYesHigh
CPP_WARN_DYNAMIC_EXCEPTION_SPECDynamic Exception SpecYes
CPP_WARN_ELABORATED_ENUM_BASEElaborated Enum BaseYes
CPP_WARN_ELABORATED_ENUM_CLASSElaborated Enum ClassYes
CPP_WARN_EMBEDDED_DIRECTIVEEmbedded DirectiveYes
CPP_WARN_EMPTY_BODYControl Loop Shall Not Have Empty BodyYes
CPP_WARN_EMPTY_DECOMPOSITIONDecomposition Group Shall Not Be EmptyYes
CPP_WARN_EMPTY_INIT_STMTNo Empty Initialization StatementsYes
CPP_WARN_EMPTY_TRANSLATION_UNITEmpty Translation UnitYes
CPP_WARN_ENUM_COMPAREEnum CompareYesHigh
CPP_WARN_ENUM_COMPARE_CONDITIONALEnum Compare ConditionalYes
CPP_WARN_ENUM_COMPARE_SWITCHEnum Compare SwitchYesHigh
CPP_WARN_ENUM_CONVERSIONEnum ConversionYes
CPP_WARN_ENUM_ENUM_CONVERSIONEnum Enum ConversionYes
CPP_WARN_ENUM_FLOAT_CONVERSIONEnum Float ConversionYes
CPP_WARN_ENUM_TOO_LARGEEnum Too LargeYes
CPP_WARN_EXCEPTIONSExceptionsYesHigh
CPP_WARN_EXCESS_INITIALIZERSExcess InitializersYes
CPP_WARN_EXIT_TIME_DESTRUCTORSExit Time DestructorsYes
CPP_WARN_EXPANSION_TO_DEFINEDExpansion to DefinedYes
CPP_WARN_EXPORT_UNNAMEDExport UnnamedYes
CPP_WARN_EXPORT_USING_DIRECTIVEExport Using DirectiveYes
CPP_WARN_EXTERN_C_COMPATExtern C CompatibilityYesHigh
CPP_WARN_EXTERN_INITIALIZERExtern InitializerYesHigh
CPP_WARN_EXTRAExtra WarningsYes
CPP_WARN_EXTRA_QUALIFICATIONExtra QualificationYesHigh
CPP_WARN_EXTRA_SEMIExtra SemicolonYes
CPP_WARN_EXTRA_SEMI_STMTExtra Semicolon in Empty Expression StatementYes
CPP_WARN_EXTRA_TOKENSExtra TokensYes
CPP_WARN_FINAL_DTOR_NON_FINAL_CLASSFinal Destructor Non-Final ClassYes
CPP_WARN_FINAL_MACROFinal Macros Should Not Be RedefinedYes
CPP_WARN_FIXED_ENUM_EXTENSIONFixed Enum ExtensionYes
CPP_WARN_FIXED_POINT_OVERFLOWFixed Point OverflowYesHigh
CPP_WARN_FLAG_ENUMFlag EnumYesHigh
CPP_WARN_FLEXIBLE_ARRAY_EXTENSIONSFlexible Array ExtensionsYes
CPP_WARN_FLOAT_CONVERSIONFloat ConversionYes
CPP_WARN_FLOAT_EQUALFloat EqualYes
CPP_WARN_FLOAT_OVERFLOW_CONVERSIONFloat Overflow ConversionYes
CPP_WARN_FLOAT_ZERO_CONVERSIONFloat Zero ConversionYes
CPP_WARN_FOR_LOOP_ANALYSISFor Loop AnalysisYes
CPP_WARN_FORMATFormat StringYesHigh
CPP_WARN_FORMAT_EXTRA_ARGSFormat Extra ArgsYesHigh
CPP_WARN_FORMAT_INSUFFICIENT_ARGSFormat Insufficient ArgsYesHigh
CPP_WARN_FORMAT_INVALID_SPECIFIERFormat Invalid SpecifierYesHigh
CPP_WARN_FORMAT_NON_ISOFormat Non-ISOYes
CPP_WARN_FORMAT_NONLITERALFormat Non-LiteralYes
CPP_WARN_FORMAT_PEDANTICFormat PedanticYes
CPP_WARN_FORMAT_SECURITYFormat SecurityYesHigh
CPP_WARN_FORMAT_TYPE_CONFUSIONFormat Type ConfusionYes
CPP_WARN_FORMAT_ZERO_LENGTHFormat Zero LengthYesHigh
CPP_WARN_FORTIFY_SOURCEFortify SourceYesHigh
CPP_WARN_FOUR_CHAR_CONSTANTSFour Char ConstantsYes
CPP_WARN_FRAME_ADDRESSFrame AddressYes
CPP_WARN_FREE_NONHEAP_OBJECTFree Non-Heap ObjectYesHigh
CPP_WARN_FUNCTION_MULTIVERSIONFunction Multi-VersionYes
CPP_WARN_FUSE_LD_PATHFuse LD PathYes
CPP_WARN_GCC_COMPATGCC CompatibilityYes
CPP_WARN_GLOBAL_CONSTRUCTORSGlobal ConstructorsYes
CPP_WARN_GLOBAL_ISELGlobalISel (Global Instruction Selection) FrameworkYes
CPP_WARN_GNU_ALIGNOF_EXPRESSIONGNU Alignof ExpressionYes
CPP_WARN_GNU_ANONYMOUS_STRUCTGNU Anonymous StructYes
CPP_WARN_GNU_ARRAY_MEMBER_PAREN_INITGNU Array Member Parentheses InitYes
CPP_WARN_GNU_AUTO_TYPEGNU Auto TypeYes
CPP_WARN_GNU_BINARY_LITERALGNU Binary LiteralYes
CPP_WARN_GNU_CASE_RANGEGNU Case RangeYes
CPP_WARN_GNU_COMPLEX_INTEGERGNU Complex IntegerYes
CPP_WARN_GNU_COMPOUND_LITERAL_INITIALIZERGNU Compound Literal InitializerYes
CPP_WARN_GNU_CONDITIONAL_OMITTED_OPERANDGNU Conditional Omitted OperandYes
CPP_WARN_GNU_DESIGNATORGNU DesignatorYes
CPP_WARN_GNU_EMPTY_INITIALIZERGNU Empty InitializerYes
CPP_WARN_GNU_EMPTY_STRUCTGNU Empty StructYes
CPP_WARN_GNU_FLEXIBLE_ARRAY_INITIALIZERGNU Flexible Array InitializerYes
CPP_WARN_GNU_FLEXIBLE_ARRAY_UNION_MEMBERGNU Flexible Array Union MemberYes
CPP_WARN_GNU_FOLDING_CONSTANTGNU Folding ConstantYes
CPP_WARN_GNU_IMAGINARY_CONSTANTGNU Imaginary ConstantYes
CPP_WARN_GNU_INCLUDE_NEXTGNU Include NextYes
CPP_WARN_GNU_INLINE_CPP_WITHOUT_EXTERNGNU Inline Cpp Without ExternYes
CPP_WARN_GNU_LABEL_AS_VALUEGNU Label as ValueYes
CPP_WARN_GNU_LINE_MARKERGNU Line MarkerYes
CPP_WARN_GNU_NULL_POINTER_ARITHMETICGNU Null Pointer ArithmeticYes
CPP_WARN_GNU_POINTER_ARITHGNU Pointer ArithmeticYes
CPP_WARN_GNU_REDECLARED_ENUMGNU Re-Declared EnumYes
CPP_WARN_GNU_STATEMENT_EXPRESSIONGNU Statement ExpressionYes
CPP_WARN_GNU_STATEMENT_EXPRESSION_FROM_MACRO_EXPANSIONGNU Statement Expression from Macro ExpansionYes
CPP_WARN_GNU_STATIC_FLOAT_INITGNU Static Float InitYes
CPP_WARN_GNU_STRING_LITERAL_OPERATOR_TEMPLATEGNU String Literal Operator TemplateYes
CPP_WARN_GNU_UNION_CASTGNU Union CastYes
CPP_WARN_GNU_VARIABLE_SIZED_TYPE_NOT_AT_ENDGNU Variable Sized Type Not at EndYes
CPP_WARN_GNU_ZERO_LINE_DIRECTIVEGNU Zero Line DirectiveYes
CPP_WARN_GNU_ZERO_VARIADIC_MACRO_ARGUMENTSGNU Zero Variadic Macro ArgumentsYes
CPP_WARN_HEADER_GUARDHeader GuardYesHigh
CPP_WARN_HEADER_HYGIENEHeader HygieneYes
CPP_WARN_IDIOMATIC_PARENTHESESIdiomatic ParenthesesYes
CPP_WARN_IGNORED_ATTRIBUTESIgnored AttributesYesHigh
CPP_WARN_IGNORED_AVAILABILITY_WITHOUT_SDK_SETTINGSIgnored Availability Without Sdk SettingsYes
CPP_WARN_IGNORED_OPTIMIZATION_ARGUMENTIgnored Optimization ArgumentYes
CPP_WARN_IGNORED_PRAGMA_INTRINSICIgnored Pragma IntrinsicYes
CPP_WARN_IGNORED_PRAGMASIgnored PragmasYes
CPP_WARN_IGNORED_REFERENCE_QUALIFIERSIgnored Reference QualifiersYesHigh
CPP_WARN_IMPLICIT_CONST_INT_FLOAT_CONVERSIONImplicit Const Int Float ConversionYesHigh
CPP_WARN_IMPLICIT_CONVERSION_FLOATING_POINT_TO_BOOLImplicit Conversion Floating Point to BoolYesHigh
CPP_WARN_IMPLICIT_EXCEPTION_SPEC_MISMATCHImplicit Exception Spec MismatchYesHigh
CPP_WARN_IMPLICIT_FALLTHROUGHImplicit FallthroughYes
CPP_WARN_IMPLICIT_FALLTHROUGH_PER_FUNCTIONImplicit Fallthrough Per FunctionYes
CPP_WARN_IMPLICIT_FIXED_POINT_CONVERSIONImplicit Fixed Point ConversionYesHigh
CPP_WARN_IMPLICIT_FLOAT_CONVERSIONImplicit Float ConversionYes
CPP_WARN_IMPLICIT_FUNCTION_DECLARATIONImplicit Function DeclarationYes
CPP_WARN_IMPLICIT_INTImplicit IntYes
CPP_WARN_IMPLICIT_INT_CONVERSIONImplicit Int ConversionYes
CPP_WARN_IMPLICIT_INT_FLOAT_CONVERSIONImplicit Int Float ConversionYes
CPP_WARN_IMPLICIT_RETAIN_SELFImplicit Retain SelfYes
CPP_WARN_IMPLICITLY_UNSIGNED_LITERALImplicitly Unsigned LiteralYesHigh
CPP_WARN_IMPORT_PREPROCESSOR_DIRECTIVE_PEDANTICImport Preprocessor Directive PedanticYes
CPP_WARN_INACCESSIBLE_BASEInaccessible BaseYesHigh
CPP_WARN_INCLUDE_NEXT_ABSOLUTE_PATHInclude Next Absolute PathYes
CPP_WARN_INCLUDE_NEXT_OUTSIDE_HEADERInclude Next Outside HeaderYes
CPP_WARN_INCOMPATIBLE_EXCEPTION_SPECIncompatible Exception SpecYesHigh
CPP_WARN_INCOMPATIBLE_FUNCTION_POINTER_TYPESIncompatible Function Pointer TypesYes
CPP_WARN_INCOMPATIBLE_LIBRARY_REDECLARATIONIncompatible Library RedeclarationYesHigh
CPP_WARN_INCOMPATIBLE_MS_STRUCTIncompatible Microsoft StructYes
CPP_WARN_INCOMPATIBLE_POINTER_TYPESIncompatible Pointer TypesYesHigh
CPP_WARN_INCOMPATIBLE_POINTER_TYPES_DISCARDS_QUALIFIERSIncompatible Pointer Types Discards QualifiersYesHigh
CPP_WARN_INCOMPATIBLE_SYSROOTIncompatible SysrootYes
CPP_WARN_INCOMPLETE_IMPLEMENTATIONIncomplete ImplementationYes
CPP_WARN_INCOMPLETE_SETJMP_DECLARATIONIncomplete Setjmp DeclarationYes
CPP_WARN_INCONSISTENT_DLLIMPORTInconsistent DLLimportYes
CPP_WARN_INCONSISTENT_MISSING_DESTRUCTOR_OVERRIDEInconsistent Missing Destructor OverrideYes
CPP_WARN_INCONSISTENT_MISSING_OVERRIDEInconsistent Missing OverrideYesHigh
CPP_WARN_INCREMENT_BOOLIncrement BoolYesHigh
CPP_WARN_INFINITE_RECURSIONInfinite RecursionYes
CPP_WARN_INITIALIZER_OVERRIDESInitializer OverridesYes
CPP_WARN_INJECTED_CLASS_NAMEInjected Class NameYesHigh
CPP_WARN_INLINE_ASMInline AssemblyYes
CPP_WARN_INLINE_NAMESPACE_REOPENED_NONINLINEInline Namespace Reopened Non-InlineYesHigh
CPP_WARN_INLINE_NEW_DELETEInline New DeleteYes
CPP_WARN_INSTANTIATION_AFTER_SPECIALIZATIONInstantiation After SpecializationYesHigh
CPP_WARN_INT_CONVERSIONInt ConversionYes
CPP_WARN_INT_IN_BOOL_CONTEXTInt in Bool ContextYes
CPP_WARN_INT_TO_POINTER_CASTInt to Pointer CastYesHigh
CPP_WARN_INT_TO_VOID_POINTER_CASTInt to Void Pointer CastYesHigh
CPP_WARN_INTEGER_OVERFLOWInteger OverflowYesHigh
CPP_WARN_INTERRUPT_SERVICE_ROUTINEInterrupt Service RoutineYes
CPP_WARN_INVALID_COMMAND_LINE_ARGUMENTInvalid Command Line ArgumentYes
CPP_WARN_INVALID_CONSTEXPRInvalid ConstexprYes
CPP_WARN_INVALID_IBOUTLETInvalid IBOutletCollection (Interface Builder Outlet Collection)Yes
CPP_WARN_INVALID_INITIALIZER_FROM_SYSTEM_HEADERInvalid Initializer from System HeaderYes
CPP_WARN_INVALID_IOS_DEPLOYMENT_TARGETInvalid iOS Deployment TargetYes
CPP_WARN_INVALID_NO_BUILTIN_NAMESInvalid No Builtin NamesYesHigh
CPP_WARN_INVALID_NORETURNInvalid Noreturn AttributeYesHigh
CPP_WARN_INVALID_OFFSETOFInvalid OffsetofYesHigh
CPP_WARN_INVALID_OR_NONEXISTENT_DIRECTORYInvalid or Nonexistent DirectoryYes
CPP_WARN_INVALID_PARTIAL_SPECIALIZATIONInvalid Partial SpecializationYes
CPP_WARN_INVALID_PP_TOKENInvalid Preprocessor TokenYesHigh
CPP_WARN_INVALID_SOURCE_ENCODINGInvalid Source EncodingYes
CPP_WARN_INVALID_TOKEN_PASTEInvalid Token PasteYes
CPP_WARN_INVALID_UTF8Invalid UTF-8Yes
CPP_WARN_JUMP_SEH_FINALLYJump SEH (Structured Exception Handling) FinallyYes
CPP_WARN_KEYWORD_COMPATKeyword CompatibilityYes
CPP_WARN_KEYWORD_MACROKeyword MacroYes
CPP_WARN_KNR_PROMOTED_PARAMETERK&R Promoted ParameterYes
CPP_WARN_LANGUAGE_EXTENSION_TOKENLanguage Extension TokenYes
CPP_WARN_LARGE_BY_VALUE_COPYLarge by Value CopyYesHigh
CPP_WARN_LINKER_WARNINGSLinker WarningsYes
CPP_WARN_LITERAL_CONVERSIONLiteral ConversionYesHigh
CPP_WARN_LITERAL_RANGELiteral RangeYesHigh
CPP_WARN_LOCAL_TYPE_TEMPLATE_ARGSLocal Type Template ArgsYes
CPP_WARN_LOGICAL_NOT_PARENTHESESLogical Not ParenthesesYesHigh
CPP_WARN_LOGICAL_OP_PARENTHESESLogical Operator ParenthesesYes
CPP_WARN_LONG_LONGLong LongYes
CPP_WARN_MACRO_REDEFINEDMacro RedefinedYesHigh
CPP_WARN_MAINMain Function ConventionsYes
CPP_WARN_MAIN_RETURN_TYPEMain Return TypeYesHigh
CPP_WARN_MALFORMED_WARNING_CHECKMalformed Warning CheckYes
CPP_WARN_MANY_BRACES_AROUND_SCALAR_INITMany Braces Around Scalar InitYesHigh
CPP_WARN_MAX_TOKENSMax TokensYes
CPP_WARN_MAX_UNSIGNED_ZEROMax Unsigned ZeroYesHigh
CPP_WARN_MEMSET_TRANSPOSED_ARGSMemset Transposed ArgsYesHigh
CPP_WARN_MEMSIZE_COMPARISONMemsize ComparisonYesHigh
CPP_WARN_MICROSOFT_ABSTRACTMicrosoft AbstractYes
CPP_WARN_MICROSOFT_ANON_TAGMicrosoft Anonymous TagYes
CPP_WARN_MICROSOFT_CASTMicrosoft CastYes
CPP_WARN_MICROSOFT_CHARIZEMicrosoft Charizing OperatorYes
CPP_WARN_MICROSOFT_COMMENT_PASTEMicrosoft Comment PasteYes
CPP_WARN_MICROSOFT_CONST_INITMicrosoft Const InitYes
CPP_WARN_MICROSOFT_CPP_MACROMicrosoft C++ MacroYes
CPP_WARN_MICROSOFT_DEFAULT_ARG_REDEFINITIONMicrosoft Default Arg RedefinitionYes
CPP_WARN_MICROSOFT_DRECTVE_SECTIONMicrosoft Drectve SectionYes
CPP_WARN_MICROSOFT_END_OF_FILEMicrosoft End of FileYes
CPP_WARN_MICROSOFT_ENUM_FORWARD_REFERENCEMicrosoft Enum Forward ReferenceYes
CPP_WARN_MICROSOFT_ENUM_VALUEMicrosoft Enum ValueYes
CPP_WARN_MICROSOFT_EXCEPTION_SPECMicrosoft Exception SpecYes
CPP_WARN_MICROSOFT_EXISTSMicrosoft ExistsYes
CPP_WARN_MICROSOFT_EXPLICIT_CONSTRUCTOR_CALLMicrosoft Explicit Constructor CallYes
CPP_WARN_MICROSOFT_EXTRA_QUALIFICATIONMicrosoft Extra QualificationYes
CPP_WARN_MICROSOFT_FIXED_ENUMMicrosoft Fixed EnumYes
CPP_WARN_MICROSOFT_FLEXIBLE_ARRAYMicrosoft Flexible ArrayYes
CPP_WARN_MICROSOFT_GOTOMicrosoft GotoYes
CPP_WARN_MICROSOFT_INACCESSIBLE_BASEMicrosoft Inaccessible BaseYes
CPP_WARN_MICROSOFT_INCLUDEMicrosoft IncludeYes
CPP_WARN_MICROSOFT_MUTABLE_REFERENCEMicrosoft Mutable ReferenceYes
CPP_WARN_MICROSOFT_PURE_DEFINITIONMicrosoft Pure DefinitionYes
CPP_WARN_MICROSOFT_REDECLARE_STATICMicrosoft Redeclare StaticYes
CPP_WARN_MICROSOFT_SEALEDMicrosoft SealedYes
CPP_WARN_MICROSOFT_STATIC_ASSERTMicrosoft Static AssertYes
CPP_WARN_MICROSOFT_TEMPLATEMicrosoft TemplateYes
CPP_WARN_MICROSOFT_TEMPLATE_SHADOWMicrosoft Template ShadowYes
CPP_WARN_MICROSOFT_UNION_MEMBER_REFERENCEMicrosoft Union Member ReferenceYes
CPP_WARN_MICROSOFT_UNQUALIFIED_FRIENDMicrosoft Unqualified FriendYes
CPP_WARN_MICROSOFT_USING_DECLMicrosoft Using DeclYes
CPP_WARN_MICROSOFT_VOID_PSEUDO_DTORMicrosoft Void Pseudo DestructorYes
CPP_WARN_MISEXPECTMisuse of __builtin_expect()Yes
CPP_WARN_MISLEADING_INDENTATIONMisleading IndentationYes
CPP_WARN_MISMATCHED_NEW_DELETEMismatched New DeleteYesHigh
CPP_WARN_MISMATCHED_TAGSMismatched TagsYes
CPP_WARN_MISSING_BRACESMissing BracesYes
CPP_WARN_MISSING_CONSTINITMissing ConstinitYes
CPP_WARN_MISSING_DECLARATIONSMissing DeclarationsYesHigh
CPP_WARN_MISSING_EXCEPTION_SPECMissing Exception SpecYesHigh
CPP_WARN_MISSING_FIELD_INITIALIZERSMissing Field InitializersYes
CPP_WARN_MISSING_METHOD_RETURN_TYPEMissing Method Return TypeYes
CPP_WARN_MISSING_NORETURNMissing Noreturn AttributeYes
CPP_WARN_MISSING_PROTOTYPE_FOR_CCMissing Prototype for Calling ConventionYes
CPP_WARN_MISSING_PROTOTYPESMissing PrototypesYes
CPP_WARN_MISSING_SELECTOR_NAMEMissing Selector NameYes
CPP_WARN_MISSING_SYSROOTMissing SysrootYes
CPP_WARN_MISSING_VARIABLE_DECLARATIONSMissing Variable DeclarationsYes
CPP_WARN_MISSPELLED_ASSUMPTIONMisspelled AssumptionYes
CPP_WARN_MODULE_CONFLICTModule ConflictYes
CPP_WARN_MODULE_FILE_CONFIG_MISMATCHModule File Config MismatchYes
CPP_WARN_MODULE_FILE_EXTENSIONModule File ExtensionYes
CPP_WARN_MODULE_IMPORT_IN_EXTERN_CModule Import in Extern CYes
CPP_WARN_MODULES_AMBIGUOUS_INTERNAL_LINKAGEModules Ambiguous Internal LinkageYes
CPP_WARN_MODULES_IMPORT_NESTED_REDUNDANTModules Import Nested RedundantYes
CPP_WARN_MSVC_NOT_FOUNDMSVC Not FoundYes
CPP_WARN_MULTICHARMultiple Characters in Character LiteralYesHigh
CPP_WARN_MULTIPLE_MOVE_VBASEMultiple Move Virtual BaseYesHigh
CPP_WARN_NESTED_ANON_TYPESNested Anon-TypesYes
CPP_WARN_NEW_RETURNS_NULLNew Returns NullYesHigh
CPP_WARN_NEWLINE_EOFNewline EOF (End of File)Yes
CPP_WARN_NODEREFNoderef AttirbuteYesHigh
CPP_WARN_NON_C_TYPEDEF_FOR_LINKAGENon-C Typedef for LinkageYesHigh
CPP_WARN_NON_LITERAL_NULL_CONVERSIONNon-Literal Null ConversionYesHigh
CPP_WARN_NON_POD_VARARGSNon-POD (Plain Old Data) Variadic ArgumentsYesHigh
CPP_WARN_NON_POWER_OF_TWO_ALIGNMENTNon-Power of Two AlignmentYesHigh
CPP_WARN_NON_VIRTUAL_DTORNon-Virtual DestructorYes
CPP_WARN_NONNULLNull as an ArgumentYesHigh
CPP_WARN_NONPORTABLE_INCLUDE_PATHNon-Portable Include PathYesHigh
CPP_WARN_NONPORTABLE_SYSTEM_INCLUDE_PATHNon-Portable System Include PathYes
CPP_WARN_NONPORTABLE_VECTOR_INITIALIZATIONNon-Portable Vector InitializationYes
CPP_WARN_NONTRIVIAL_MEMACCESSNontrivial Memory AccessYesHigh
CPP_WARN_NULL_ARITHMETICNull ArithmeticYesHigh
CPP_WARN_NULL_CHARACTERNull CharacterYesHigh
CPP_WARN_NULL_CONVERSIONNull ConversionYesHigh
CPP_WARN_NULL_DEREFERENCENull DereferenceYesHigh
CPP_WARN_NULL_POINTER_ARITHMETICNull Pointer ArithmeticYes
CPP_WARN_NULL_POINTER_SUBTRACTIONNull Pointer SubtractionYes
CPP_WARN_OBJC_BOOL_CONSTANT_CONVERSIONObjective-C Bool Constant ConversionYes
CPP_WARN_OBJC_CIRCULAR_CONTAINERObjective-C Circular ContainerYes
CPP_WARN_OBJC_MULTIPLE_METHOD_NAMESObjective-C Multiple Method NamesYes
CPP_WARN_OBJC_READONLY_WITH_SETTER_PROPERTYObjective-C Readonly with Setter PropertyYes
CPP_WARN_OBJC_SIGNED_CHAR_BOOL_IMPLICIT_FLOAT_CONVERSIONObjective-C Signed Char Bool Implicit Float ConversionYes
CPP_WARN_OBJC_SIGNED_CHAR_BOOL_IMPLICIT_INT_CONVERSIONObjective-C Signed Char Bool Implicit Int ConversionYes
CPP_WARN_ODROne Definition RuleYesHigh
CPP_WARN_OLD_STYLE_CASTOld Style CastYes
CPP_WARN_OPENMP_51_EXTENSIONSOpenMP 51 ExtensionsYes
CPP_WARN_OPENMP_CLAUSESOpenMP ClausesYes
CPP_WARN_OPENMP_LOOP_FORMOpenMP Loop FormYes
CPP_WARN_OPENMP_MAPPINGOpenMP MappingYes
CPP_WARN_OPENMP_TARGETOpenMP TargetYes
CPP_WARN_OPTION_IGNOREDOption IgnoredYes
CPP_WARN_ORDERED_COMPARE_FUNCTION_POINTERSOrdered Compare Function PointersYesHigh
CPP_WARN_OUT_OF_LINE_DECLARATIONOut of Line DeclarationYes
CPP_WARN_OUT_OF_SCOPE_FUNCTIONOut of Scope FunctionYesHigh
CPP_WARN_OVER_ALIGNEDOver AlignedYes
CPP_WARN_OVERLENGTH_STRINGSLong String LiteralsYes
CPP_WARN_OVERLOADED_SHIFT_OP_PARENTHESESOverloaded Shift Operator ParenthesesYesHigh
CPP_WARN_OVERLOADED_VIRTUALOverloaded VirtualYes
CPP_WARN_OVERRIDE_MODULEOverride ModuleYes
CPP_WARN_OVERRIDING_T_OPTIONOverriding Slash T OptionYes
CPP_WARN_PACKEDPacked AttributeYes
CPP_WARN_PADDEDImplicit PaddingYes
CPP_WARN_PARENTHESESParenthesesYes
CPP_WARN_PARENTHESES_EQUALITYParentheses EqualityYesHigh
CPP_WARN_PASS_FAILEDPass FailedYes
CPP_WARN_PCH_DATE_TIMEPCH (Precompiled Header) Date TimeYes
CPP_WARN_PEDANTICPedanticYes
CPP_WARN_PEDANTIC_CORE_FEATURESPedantic Core FeaturesYes
CPP_WARN_PESSIMIZING_MOVEPessimizing MoveYes
CPP_WARN_POINTER_ARITHPointer ArithmeticYesHigh
CPP_WARN_POINTER_BOOL_CONVERSIONPointer Bool ConversionYesHigh
CPP_WARN_POINTER_COMPAREPointer CompareYesHigh
CPP_WARN_POINTER_INTEGER_COMPAREPointer Integer CompareYesHigh
CPP_WARN_POINTER_SIGNPointer SignYesHigh
CPP_WARN_POINTER_TO_ENUM_CASTPointer to Enum CastYesHigh
CPP_WARN_POINTER_TO_INT_CASTPointer to Int CastYesHigh
CPP_WARN_POINTER_TYPE_MISMATCHPointer Type MismatchYesHigh
CPP_WARN_POISON_SYSTEM_DIRECTORIESPoison System DirectoriesYes
CPP_WARN_POTENTIALLY_EVALUATED_EXPRESSIONPotentially Evaluated ExpressionYesHigh
CPP_WARN_PRAGMA_CLANG_ATTRIBUTEPragma Clang AttributeYes
CPP_WARN_PRAGMA_MESSAGESPreprocessor #Pragma MessagesYes
CPP_WARN_PRAGMA_ONCE_OUTSIDE_HEADERPragma once Outside HeaderYesHigh
CPP_WARN_PRAGMA_PACKPragma PackYes
CPP_WARN_PRAGMA_PACK_SUSPICIOUS_INCLUDEPragma Pack Suspicious IncludeYes
CPP_WARN_PRAGMA_SYSTEM_HEADER_OUTSIDE_HEADERPragma System Header Outside HeaderYes
CPP_WARN_PRAGMASPragmasYes
CPP_WARN_PRE_C2X_COMPATPre C2X CompatibilityYes
CPP_WARN_PRE_CPP2B_COMPATPre C++2B CompatibilityYes
CPP_WARN_PRE_CPP14_COMPATPre C++14 CompatibilityYes
CPP_WARN_PRE_CPP17_COMPATPre C++17 CompatibilityYes
CPP_WARN_PRE_CPP17_COMPAT_PEDANTICPre C++17 Compatibility PedanticYes
CPP_WARN_PRE_CPP20_COMPATPre C++20 CompatibilityYes
CPP_WARN_PRE_CPP20_COMPAT_PEDANTICPre C++20 Compatibility PedanticYes
CPP_WARN_PRE_OPENMP_51_COMPATPre OpenMP 51 CompatibilityYes
CPP_WARN_PREDEFINED_IDENTIFIER_OUTSIDE_FUNCTIONPredefined Identifier Outside FunctionYes
CPP_WARN_PRIVATE_EXTERNPrivate ExternYes
CPP_WARN_PRIVATE_HEADERPrivate HeaderYes
CPP_WARN_PROFILE_INSTR_MISSINGProfile Instrumented Code MissingYes
CPP_WARN_PROFILE_INSTR_OUT_OF_DATEProfile Instrumented Code Out of DateYes
CPP_WARN_PROFILE_INSTR_UNPROFILEDProfile Instrumented Code UnprofiledYes
CPP_WARN_PSABIPSABI (Processor-Specific Application Binary Interface)Yes
CPP_WARN_QUALIFIED_VOID_RETURN_TYPEQualified Void Return TypeYesHigh
CPP_WARN_RANGE_LOOP_BIND_REFERENCERange Loop Bind ReferenceYes
CPP_WARN_RANGE_LOOP_CONSTRUCTRange Loop ConstructYes
CPP_WARN_REDECLARED_CLASS_MEMBERRe-Declared Class MemberYesHigh
CPP_WARN_REDUNDANT_CONSTEVAL_IFRedundant Consteval IfYesHigh
CPP_WARN_REDUNDANT_MOVERedundant MoveYes
CPP_WARN_REDUNDANT_PARENSRedundant ParenthesesYes
CPP_WARN_REGISTERRegister KeywordYes
CPP_WARN_REINTERPRET_BASE_CLASSReinterpret Base ClassYesHigh
CPP_WARN_REORDER_CTORReorder ConstructorYes
CPP_WARN_REORDER_INIT_LISTReorder Initializer ListYesHigh
CPP_WARN_RESERVED_IDENTIFIERReserved IdentifierYes
CPP_WARN_RESERVED_MACRO_IDENTIFIERReserved Macro IdentifierYes
CPP_WARN_RESERVED_USER_DEFINED_LITERALReserved User Defined LiteralYes
CPP_WARN_RESTRICT_EXPANSIONRestrict ExpansionYes
CPP_WARN_RETAINED_LANGUAGE_LINKAGERetained Language LinkageYes
CPP_WARN_RETURN_STACK_ADDRESSReturn Stack AddressYesHigh
CPP_WARN_RETURN_TYPEReturn TypeYesHigh
CPP_WARN_RETURN_TYPE_C_LINKAGEReturn Type C LinkageYesHigh
CPP_WARN_REWRITE_NOT_BOOLRewrite Not BoolYes
CPP_WARN_RTTIRun-Time Type InformationYes
CPP_WARN_SARIF_FORMAT_UNSTABLESARIF Format UnstableYes
CPP_WARN_SECTIONSection AttributesYes
CPP_WARN_SELF_ASSIGNSelf AssignYes
CPP_WARN_SELF_ASSIGN_FIELDSelf Assign FieldYesHigh
CPP_WARN_SELF_ASSIGN_OVERLOADEDSelf Assign OverloadedYes
CPP_WARN_SELF_MOVESelf MoveYes
CPP_WARN_SENTINELSentinel AttributeYes
CPP_WARN_SERIALIZED_DIAGNOSTICSSerialized DiagnosticsYes
CPP_WARN_SHADOWShadowing IdentifiersYes
CPP_WARN_SHADOW_FIELDShadowing FieldYes
CPP_WARN_SHADOW_FIELD_IN_CONSTRUCTORShadowing Field in ConstructorYes
CPP_WARN_SHADOW_FIELD_IN_CONSTRUCTOR_MODIFIEDShadowing Field in Constructor ModifiedYes
CPP_WARN_SHADOW_UNCAPTURED_LOCALShadowing Uncaptured LocalYes
CPP_WARN_SHIFT_COUNT_NEGATIVEShift Count NegativeYesHigh
CPP_WARN_SHIFT_COUNT_OVERFLOWShift Count OverflowYesHigh
CPP_WARN_SHIFT_NEGATIVE_VALUEShift Negative ValueYesHigh
CPP_WARN_SHIFT_OP_PARENTHESESShift Operator ParenthesesYesHigh
CPP_WARN_SHIFT_OVERFLOWShift OverflowYesHigh
CPP_WARN_SHIFT_SIGN_OVERFLOWShift Sign OverflowYes
CPP_WARN_SHORTEN_64_TO_32Shorten Integer Type WidthYes
CPP_WARN_SIGN_COMPARESign CompareYes
CPP_WARN_SIGN_CONVERSIONSign ConversionYes
CPP_WARN_SIGNED_ENUM_BITFIELDSigned Enum BitfieldYes
CPP_WARN_SIGNED_UNSIGNED_WCHARSigned Unsigned WcharYes
CPP_WARN_SINGLE_BIT_BITFIELD_CONSTANT_CONVERSIONSingle Bit Bitfield Constant ConversionYesHigh
CPP_WARN_SIZEOF_ARRAY_ARGUMENTSizeof Array ArgumentYesHigh
CPP_WARN_SIZEOF_ARRAY_DECAYSizeof Array DecayYesHigh
CPP_WARN_SIZEOF_ARRAY_DIVSizeof Array DivisionYesHigh
CPP_WARN_SIZEOF_POINTER_DIVSizeof Pointer DivisionYesHigh
CPP_WARN_SIZEOF_POINTER_MEMACCESSSizeof Pointer Memory AccessYesHigh
CPP_WARN_SLASH_U_FILENAMESlash U FilenameYes
CPP_WARN_SLH_ASM_GOTOSLH (Speculative Load Hardening) Assembly GotoYes
CPP_WARN_SOMETIMES_UNINITIALIZEDSometimes UninitializedYes
CPP_WARN_SOURCE_USES_OPENMPSource Uses OpenMPYes
CPP_WARN_SPIR_COMPATSPIR (Sampler Initializer) CompatibilityYes
CPP_WARN_STACK_EXHAUSTEDStack ExhaustedYes
CPP_WARN_STACK_PROTECTORStack ProtectorYes
CPP_WARN_STATIC_FLOAT_INITStatic Float InitYes
CPP_WARN_STATIC_IN_INLINEStatic in InlineYes
CPP_WARN_STATIC_INLINE_EXPLICIT_INSTANTIATIONStatic Inline Explicit InstantiationYesHigh
CPP_WARN_STATIC_LOCAL_IN_INLINEStatic Local in InlineYesHigh
CPP_WARN_STATIC_SELF_INITStatic Self InitYesHigh
CPP_WARN_STDLIBCXX_NOT_FOUNDLibStdC++ Headers Not FoundYes
CPP_WARN_STRICT_POTENTIALLY_DIRECT_SELECTORStrict Potentially Direct SelectorYes
CPP_WARN_STRICT_PROTOTYPESStrict PrototypesYes
CPP_WARN_STRICT_SELECTOR_MATCHStrict Selector MatchYes
CPP_WARN_STRING_COMPAREString CompareYesHigh
CPP_WARN_STRING_CONCATENATIONString ConcatenationYes
CPP_WARN_STRING_CONVERSIONString ConversionYes
CPP_WARN_STRING_PLUS_CHARString Plus CharYesHigh
CPP_WARN_STRING_PLUS_INTString Plus IntYesHigh
CPP_WARN_STRLCPY_STRLCAT_SIZEStrlcpy Strlcat SizeYesHigh
CPP_WARN_STRNCAT_SIZEStrncat SizeYesHigh
CPP_WARN_SUGGEST_DESTRUCTOR_OVERRIDESuggest Destructor OverrideYes
CPP_WARN_SUGGEST_OVERRIDESuggest OverrideYes
CPP_WARN_SUPER_CLASS_METHOD_MISMATCHSuper Class Method MismatchYes
CPP_WARN_SUSPICIOUS_BZEROSuspicious Argument for Bzero FunctionYes
CPP_WARN_SWITCHSwitch StatementsYesHigh
CPP_WARN_SWITCH_BOOLSwitch BoolYesHigh
CPP_WARN_SWITCH_ENUMSwitch EnumYes
CPP_WARN_SYNC_FETCH_AND_NAND_SEMANTICS_CHANGEDSync Fetch And Nand Semantics ChangedYes
CPP_WARN_TARGET_CLONES_MIXED_SPECIFIERSTarget Clones Mixed SpecifiersYes
CPP_WARN_TAUTOLOGICAL_BITWISE_COMPARETautological Bitwise CompareYes
CPP_WARN_TAUTOLOGICAL_COMPARETautological CompareYes
CPP_WARN_TAUTOLOGICAL_CONSTANT_COMPARETautological Constant CompareYesHigh
CPP_WARN_TAUTOLOGICAL_CONSTANT_OUT_OF_RANGE_COMPARETautological Constant Out of Range CompareYesHigh
CPP_WARN_TAUTOLOGICAL_OVERLAP_COMPARETautological Overlap CompareYes
CPP_WARN_TAUTOLOGICAL_POINTER_COMPARETautological Pointer CompareYesHigh
CPP_WARN_TAUTOLOGICAL_TYPE_LIMIT_COMPARETautological Type Limit CompareYes
CPP_WARN_TAUTOLOGICAL_UNDEFINED_COMPARETautological Undefined CompareYesHigh
CPP_WARN_TAUTOLOGICAL_UNSIGNED_CHAR_ZERO_COMPARETautological Unsigned Char Zero CompareYes
CPP_WARN_TAUTOLOGICAL_UNSIGNED_ENUM_ZERO_COMPARETautological Unsigned Enum Zero CompareYes
CPP_WARN_TAUTOLOGICAL_UNSIGNED_ZERO_COMPARETautological Unsigned Zero CompareYes
CPP_WARN_TAUTOLOGICAL_VALUE_RANGE_COMPARETautological Value Range CompareYes
CPP_WARN_TCB_ENFORCEMENTTCB (Trusted Computing Base) EnforcementYes
CPP_WARN_TENTATIVE_DEFINITION_INCOMPLETE_TYPETentative Definition Incomplete TypeYesHigh
CPP_WARN_THREAD_SAFETY_ANALYSISThread Safety AnalysisYes
CPP_WARN_THREAD_SAFETY_ATTRIBUTESThread Safety AttributesYes
CPP_WARN_THREAD_SAFETY_BETAThread Safety BetaYes
CPP_WARN_THREAD_SAFETY_NEGATIVEThread Safety NegativeYes
CPP_WARN_THREAD_SAFETY_PRECISEThread Safety PreciseYes
CPP_WARN_THREAD_SAFETY_REFERENCEThread Safety ReferenceYes
CPP_WARN_THREAD_SAFETY_VERBOSEThread Safety VerboseYes
CPP_WARN_TRIGRAPHSTrigraphsYesHigh
CPP_WARN_TYPE_SAFETYType SafetyYesHigh
CPP_WARN_TYPEDEF_REDEFINITIONTypedef RedefinitionYesHigh
CPP_WARN_TYPENAME_MISSINGTypename MissingYesHigh
CPP_WARN_UNABLE_TO_OPEN_STATS_FILEUnable to Open Stats FileYes
CPP_WARN_UNALIGNED_ACCESSUnaligned AccessYes
CPP_WARN_UNALIGNED_QUALIFIER_IMPLICIT_CASTUnaligned Qualifier Implicit CastYes
CPP_WARN_UNDEFUndefined MacrosYes
CPP_WARN_UNDEF_PREFIXUndefined Macros of a Certain PrefixYes
CPP_WARN_UNDEFINED_BOOL_CONVERSIONUndefined Bool ConversionYesHigh
CPP_WARN_UNDEFINED_FUNC_TEMPLATEUndefined Function TemplateYes
CPP_WARN_UNDEFINED_INLINEUndefined InlineYesHigh
CPP_WARN_UNDEFINED_INTERNALUndefined InternalYesHigh
CPP_WARN_UNDEFINED_INTERNAL_TYPEUndefined Internal TypeYes
CPP_WARN_UNDEFINED_REINTERPRET_CASTUndefined Reinterpret CastYes
CPP_WARN_UNDEFINED_VAR_TEMPLATEUndefined Var TemplateYesHigh
CPP_WARN_UNDERALIGNED_EXCEPTION_OBJECTUnderaligned Exception ObjectYes
CPP_WARN_UNEVALUATED_EXPRESSIONUnevaluated ExpressionYesHigh
CPP_WARN_UNGUARDED_AVAILABILITYUnguarded AvailabilityYes
CPP_WARN_UNGUARDED_AVAILABILITY_NEWUnguarded Availability NewYesHigh
CPP_WARN_UNICODEUnicode Escape SequencesYesHigh
CPP_WARN_UNICODE_HOMOGLYPHUnicode HomoglyphYesHigh
CPP_WARN_UNICODE_WHITESPACEUnicode WhitespaceYesHigh
CPP_WARN_UNICODE_ZERO_WIDTHUnicode Zero WidthYesHigh
CPP_WARN_UNINITIALIZEDUninitializedYes
CPP_WARN_UNINITIALIZED_CONST_REFERENCEUninitialized Const ReferenceYes
CPP_WARN_UNKNOWN_ARGUMENTUnknown ArgumentYes
CPP_WARN_UNKNOWN_ASSUMPTIONUnknown AssumptionYes
CPP_WARN_UNKNOWN_ATTRIBUTESUnknown AttributesYes
CPP_WARN_UNKNOWN_DIRECTIVESUnknown DirectivesYesHigh
CPP_WARN_UNKNOWN_ESCAPE_SEQUENCEUnknown Escape SequenceYesHigh
CPP_WARN_UNKNOWN_PRAGMASUnknown PragmasYes
CPP_WARN_UNKNOWN_SANITIZERSUnknown SanitizersYes
CPP_WARN_UNKNOWN_WARNING_OPTIONUnknown Warning OptionYes
CPP_WARN_UNNAMED_TYPE_TEMPLATE_ARGSUnnamed Type Template ArgsYes
CPP_WARN_UNNEEDED_INTERNAL_DECLARATIONUnneeded Internal DeclarationYes
CPP_WARN_UNNEEDED_MEMBER_FUNCTIONUnneeded Member FunctionYes
CPP_WARN_UNQUALIFIED_STD_CAST_CALLUnqualified Standard Cast CallYesHigh
CPP_WARN_UNREACHABLE_CODEUnreachable CodeYes
CPP_WARN_UNREACHABLE_CODE_BREAKUnreachable Code BreakYes
CPP_WARN_UNREACHABLE_CODE_FALLTHROUGHUnreachable Code FallthroughYes
CPP_WARN_UNREACHABLE_CODE_GENERIC_ASSOCUnreachable Code Generic AssocYes
CPP_WARN_UNREACHABLE_CODE_LOOP_INCREMENTUnreachable Code Loop IncrementYes
CPP_WARN_UNREACHABLE_CODE_RETURNUnreachable Code ReturnYes
CPP_WARN_UNSEQUENCEDUnsequenced ModificationsYesHigh
CPP_WARN_UNSUPPORTED_ABIUnsupported ABI (Application Binary Interface)Yes
CPP_WARN_UNSUPPORTED_ABSUnsupported Absolute Value ArgumentYes
CPP_WARN_UNSUPPORTED_AVAILABILITY_GUARDUnsupported Availability GuardYesHigh
CPP_WARN_UNSUPPORTED_CBUnsupported Compact BranchesYes
CPP_WARN_UNSUPPORTED_DLL_BASE_CLASS_TEMPLATEUnsupported DLL Base Class TemplateYes
CPP_WARN_UNSUPPORTED_FLOATING_POINT_OPTUnsupported Floating Point OptionYes
CPP_WARN_UNSUPPORTED_FRIENDUnsupported FriendYesHigh
CPP_WARN_UNSUPPORTED_GPOPTUnsupported GPopt (Gaussian Process Optimization)Yes
CPP_WARN_UNSUPPORTED_NANUnsupported Nan ArgumentYes
CPP_WARN_UNSUPPORTED_TARGET_OPTUnsupported Target OptionYes
CPP_WARN_UNSUPPORTED_VISIBILITYUnsupported VisibilityYes
CPP_WARN_UNUSABLE_PARTIAL_SPECIALIZATIONUnusable Partial SpecializationYes
CPP_WARN_UNUSED_BUT_SET_PARAMETERUnused but Set ParameterYes
CPP_WARN_UNUSED_BUT_SET_VARIABLEUnused but Set VariableYes
CPP_WARN_UNUSED_COMMAND_LINE_ARGUMENTUnused Command Line ArgumentYes
CPP_WARN_UNUSED_COMPARISONUnused ComparisonYesHigh
CPP_WARN_UNUSED_CONST_VARIABLEUnused Const VariableYes
CPP_WARN_UNUSED_EXCEPTION_PARAMETERUnused Exception ParameterYes
CPP_WARN_UNUSED_FUNCTIONUnused FunctionYes
CPP_WARN_UNUSED_GETTER_RETURN_VALUEUnused Getter Return ValueYes
CPP_WARN_UNUSED_LABELUnused LabelYes
CPP_WARN_UNUSED_LAMBDA_CAPTUREUnused Lambda CaptureYes
CPP_WARN_UNUSED_LOCAL_TYPEDEFUnused Local TypedefYes
CPP_WARN_UNUSED_MACROSUnused MacrosYes
CPP_WARN_UNUSED_MEMBER_FUNCTIONUnused Member FunctionYes
CPP_WARN_UNUSED_PARAMETERUnused ParameterYes
CPP_WARN_UNUSED_PRIVATE_FIELDUnused Private FieldYes
CPP_WARN_UNUSED_PROPERTY_IVARUnused Property IVar (Instance Variable)Yes
CPP_WARN_UNUSED_RESULTUnused ResultYesHigh
CPP_WARN_UNUSED_TEMPLATEUnused TemplateYes
CPP_WARN_UNUSED_VALUEUnused ValueYesHigh
CPP_WARN_UNUSED_VARIABLEUnused VariableYes
CPP_WARN_UNUSED_VOLATILE_LVALUEUnused Volatile LvalueYesHigh
CPP_WARN_USED_BUT_MARKED_UNUSEDUsed but Marked UnusedYes
CPP_WARN_USER_DEFINED_LITERALSUser Defined LiteralsYesHigh
CPP_WARN_USER_DEFINED_WARNINGSUser Defined WarningsYes
CPP_WARN_VARARGSVariadic ArgumentsYesHigh
CPP_WARN_VARIADIC_MACROSVariadic MacrosYes
CPP_WARN_VEC_ELEM_SIZEVector Element SizeYes
CPP_WARN_VECTOR_CONVERSIONVector ConversionYes
CPP_WARN_VEXING_PARSEVexing Parse OccurrencesYesHigh
CPP_WARN_VISIBILITYVisibility of DeclarationsYesHigh
CPP_WARN_VLAVLA (Variable Length Array)Yes
CPP_WARN_VLA_EXTENSIONVLA (Variable Length Array) ExtensionYes
CPP_WARN_VOID_POINTER_TO_ENUM_CASTVoid Pointer to Enum CastYesHigh
CPP_WARN_VOID_POINTER_TO_INT_CASTVoid Pointer to Int CastYesHigh
CPP_WARN_VOID_PTR_DEREFERENCEVoid Pointer DereferenceYesHigh
CPP_WARN_WARNINGSPreprocessor #WarningsYes
CPP_WARN_WASM_EXCEPTION_SPECWasm Exception SpecYes
CPP_WARN_WEAK_VTABLESWeak VTables (Virtual Tables)Yes
CPP_WARN_WRITABLE_STRINGSWritable StringsYesHigh
CPP_WARN_XOR_USED_AS_POWXor Used as PowerYesHigh
CPP_WARN_ZERO_AS_NULL_POINTER_CONSTANTZero as Null Pointer ConstantYes
CPP_WARN_ZERO_LENGTH_ARRAYZero Length ArrayYes
CTR50-CPPGuarantee that container indices and iterators are within the valid rangeYesHigh
CTR51-CPPUse valid references, pointers, and iterators to reference elements of a containerYesHigh
CTR52-CPPGuarantee that library functions do not overflowYesHigh
CTR53-CPPUse valid iterator rangesYesHigh
CTR54-CPPDo not subtract iterators that do not refer to the same containerYesMedium
CTR55-CPPDo not use an additive operator on an iterator if the result would overflowYes
CTR56-CPPDo not use pointer arithmetic on polymorphic objectsYesHigh
CTR57-CPPProvide a valid ordering predicateYesLow
CTR58-CPPPredicate function objects should not be mutableYesLow
DCL30-C-ADeclare objects with appropriate storage durations - assigning addressesYesHigh
DCL30-C-BDeclare objects with appropriate storage durations - returning addressesYesHigh
DCL31-CDeclare identifiers before using themYesLow
DCL36-CDo not declare an identifier with conflicting linkage classificationsYesMedium
DCL37-CDo not declare or define a reserved identifierYesLow
DCL38-CUse the correct syntax when declaring a flexible array memberYesLow
DCL39-CAvoid information leakage when passing a structure across a trust boundaryNoLow
DCL40-CDo not create incompatible declarations of the same function or object YesLow
DCL41-CDo not declare variables inside a switch statement before the first case labelYesMedium
DCL50-CPPDo not define a C-style variadic functionYesHigh
DCL52-CPPNever qualify a reference type with const or volatileYesLow
DCL54-CPPOverload allocation and deallocation functions as a pair in the same scopeYesLow
DCL55-CPPAvoid information leakage when passing a class object across a trust boundaryNoLow
DCL56-CPPAvoid cycles during initialization of static objectsYesLow
DCL57-CPPDo not let exceptions escape from destructors or deallocation functionsYesLow
DCL58-CPPDo not modify the standard namespacesYesHigh
DCL59-CPPDo not define an unnamed namespace in a header fileYesMedium
DCL60-CPPObey the one-definition ruleYesHigh
EFFECTIVECPP_022. Do Not Use #defineYes
EFFECTIVECPP_033. Use Const whenever possibleYes
EFFECTIVECPP_044. Make sure that objects are initialized before they are usedYes
EFFECTIVECPP_077. Non-Virtual Destructors in Base ClassesYes
EFFECTIVECPP_1616. Use the same form in corresponding uses of new and deleteYes
EFFECTIVECPP_1717. Store newed objects in smart pointers in standalone statementsYes
EFFECTIVECPP_2020. Prefer pass-by-reference-to-const to pass by valueYes
EFFECTIVECPP_2222. Datamembers should be declared privateYes
EFFECTIVECPP_2626. Postpone variable definitions as long as possibleYes
EFFECTIVECPP_2727. Minimize castingYes
EFFECTIVECPP_3333. Avoid hiding inherited namesYes
EFFECTIVECPP_3535. Consider alternatives to virtual functionsYes
EFFECTIVECPP_3636. Never redefine an inherited non-virtual functionYes
ENV30-CDo not modify the object referenced by the return value of certain functionsYesLow
ENV31-CDo not rely on an environment pointer following an operation that may invalidate itYesLow
ENV32-CAll exit handlers must return normallyYesMedium
ENV33-CDo not call system()YesHigh
ENV34-CDo not store pointers returned by certain functionsYesLow
ERR30-CTake care when reading errnoYesMedium
ERR32-CDo not rely on indeterminate values of errnoNoLow
ERR33-CDetect and handle standard library errorsYesHigh
ERR34-CDetect errors when converting a string to a numberYesMedium
ERR51-CPPHandle all exceptionsYesLow
ERR52-CPPDo not use setjmp() or longjmp()YesLow
ERR53-CPPDo not reference base classes or class data members in a constructor or destructor function-try-block handlerYesLow
ERR54-CPPCatch handlers should order their parameter types from most derived to least derivedYesMedium
ERR55-CPPHonor exception specificationsYesLow
ERR57-CPPDo not leak resources when handling exceptionsYesLow
ERR58-CPPHandle all exceptions thrown before main() begins executingYesLow
ERR60-CPPException objects must be nothrow copy constructibleYesLow
ERR61-CPPCatch exceptions by lvalue referenceYesLow
ERR62-CPPDetect errors when converting a string to a numberYesMedium
EXP30-C-ADo not depend on the order of evaluation for side effects - callsYesMedium
EXP30-C-BDo not depend on the order of evaluation for side effects - otherYesMedium
EXP32-CDo not access a volatile object through a nonvolatile referenceYesLow
EXP33-CDo not read uninitialized memoryYesHigh
EXP34-CDo not dereference null pointersYesHigh
EXP35-CDo not modify objects with temporary lifetimeNoLow
EXP36-CDo not cast pointers into more strictly aligned pointer typesYesLow
EXP37-CCall functions with the correct number and type of argumentsYesMedium
EXP39-CDo not access a variable through a pointer of an incompatible typeYesMedium
EXP40-CDo not modify constant objectsNoLow
EXP42-CDo not compare padding dataYesMedium
EXP43-CAvoid undefined behavior when using restrict-qualified pointersNoMedium
EXP44-CDo not rely on side effects in operands to sizeof, _Alignof, or _GenericYesLow
EXP45-CDo not perform assignments in selection statementsYesLow
EXP46-CDo not use a bitwise operator with a Boolean-like operandYesLow
EXP47-CDo not call va_arg with an argument of the incorrect typeYesMedium
EXP50-CPPDo not depend on the order of evaluation for side effectsYesMedium
EXP51-CPPDo not delete an array through a pointer of the incorrect typeYesLow
EXP52-CPPDo not rely on side effects in unevaluated operandsYesLow
EXP53-CPPDo not read uninitialized memoryYesHigh
EXP54-CPPDo not access an object outside of its lifetimeYesHigh
EXP55-CPPDo not access a cv-qualified object through a cv-unqualified typeYesMedium
EXP56-CPPDo not call a function with a mismatched language linkageNoLow
EXP57-CPPDo not cast or delete pointers to incomplete classesYesMedium
EXP58-CPPPass an object of the correct type to va_startYesMedium
EXP59-CPPUse offsetof() on valid types and membersYesMedium
EXP61-CPPA lambda object must not outlive any of its reference captured objectsYesHigh
EXP62-CPPDo not access the bits of an object representation that are not part of the object's value representationYesHigh
EXP63-CPPDo not rely on the value of a moved-from objectYesMedium
FIO30-CExclude user input from format stringsYesHigh
FIO32-CDo not perform operations on devices that are only appropriate for filesNoMedium
FIO34-CDistinguish between characters read from a file and EOF or WEOFNoHigh
FIO37-CDo not assume that fgets() or fgetws() returns a nonempty string when successfulYesHigh
FIO38-CDo not copy a FILE objectYesLow
FIO39-CDo not alternately input and output from a stream without an intervening flush or positioning callYesLow
FIO40-CReset strings on fgets() or fgetws() failureYesLow
FIO41-CDo not call getc(), putc(), getwc(), or putwc() with a stream argument that has side effectsYesLow
FIO42-CClose files when they are no longer neededYesMedium
FIO44-COnly use values for fsetpos() that are returned from fgetpos()YesMedium
FIO45-CAvoid TOCTOU race conditions while accessing filesYesHigh
FIO46-CDo not access a closed fileYesMedium
FIO47-CUse valid format stringsYesHigh
FIO50-CPPDo not alternately input and output from a file stream without an intervening positioning callYesLow
FIO51-CPPClose files when they are no longer neededYesMedium
FLP30-CDo not use floating-point variables as loop countersYesLow
FLP32-CPrevent or detect domain and range errors in math functionsNoMedium
FLP34-CEnsure that floating-point conversions are within range of the new typeNoLow
FLP36-CPreserve precision when converting integral values to floating-point typeNoLow
FLP37-CDo not use object representations to compare floating-point valuesYesLow
HIS_011. Comment Density (COMF)Yes
HIS_022. Number of Paths(PATH)Yes
HIS_033. Number of Goto Statements(GOTO)Yes
HIS_044. Cyclomatic Complexity (v(G))Yes
HIS_055. Calling Functions (CALLING)Yes
HIS_066. Called Functions (CALLS)Yes
HIS_077. Function Parameters (PARAM)Yes
HIS_088. Number of Staments(STMT)Yes
HIS_099. Number of call levels(LEVEL)Yes
HIS_1010. Number of return points (RETURN)Yes
HIS_1111. Language scope(VOCF)Yes
HIS_1212. Recursion (AP_CG_CYCLE)Yes
HIS_1313. Statements Changed (SCHG)Yes
HIS_1414. Statements Deleted (SDEL)Yes
HIS_1515. New Statements (SNEW)Yes
HIS_1616. Stability Index (S)Yes
HIS_1717. MISRA-HIS Violations (NOMV)Yes
HIS_1818. MISRA-HIS Violations per Rule (NOMVPR)Yes
INT30-CEnsure that unsigned integer operations do not wrapYesHigh
INT31-CEnsure that unsigned integer operations do not result in lost or misinterpreted dataYesHigh
INT32-CEnsure that operations on signed integers do not result in overflowNoHigh
INT33-CDivision by ZeroYesLow
INT34-CDo not shift an expression by a negative number of bits or by greater than or equal to the number of bits that exist in the operandNoLow
INT35-CUse correct integer precisionsNoLow
INT36-CConverting a pointer to integer or integer to pointerYesLow
INT50-CPPDo not cast to an out-of-range enumeration valueYesMedium
M0-1-1A project shall not contain unreachable codeYesAutomatedRequired
M0-1-2A project shall not contain infeasible pathsYesAutomatedRequired
M0-1-3A project shall not contain unused variablesYesAutomatedRequired
M0-1-4A project shall not contain non-volatile POD variables having only one use.YesAutomatedRequired
M0-1-8All functions with void return type shall have external side effect(s)YesAutomatedRequired
M0-1-10Every defined function shall be called at least once.YesAutomatedAdvisory
M0-2-1Assigning Object to an Overlapping ObjectYesAutomatedRequired
M0-4-1Undocumented Use of Scaled-integer or Fixed-point ArithmeticYesNon-automatedRequired
M0-4-2Undocumented Use of Floating-point ArithmeticYesNon-automatedRequired
M2-7-1The character sequence /* shall not be used within a C-style comment.YesAutomatedRequired
M2-10-1Different identifiers shall be typographically unambiguousYesAutomatedRequired
M2-13-2Octal constants (other than zero) and octal escape sequences (other than "\0" ) shall not be used.YesAutomatedRequired
M2-13-3A "U" suffix shall be applied to all octal or hexadecimal integer literals of unsigned type.YesAutomatedRequired
M2-13-4Literal suffixes shall be upper caseYesAutomatedRequired
M3-1-2Functions shall not be declared at block scopeYesAutomatedRequired
M3-2-1All declarations of an object or function shall have compatible typesYesAutomatedRequired
M3-2-2The One Definition RuleYesAutomatedRequired
M3-2-3A type, object or function that is used in multiple translation units shall be declared in one and only one fileYesAutomatedRequired
M3-2-4An identifier with external linkage shall have exactly one definitionYesAutomatedRequired
M3-3-2If a function has internal linkage then all redeclarations shall include the static storage class specifierYesAutomatedRequired
M3-4-1Declarations at Lowest ScopeYesAutomatedRequired
M3-9-1The types used for an object, a function return type, or a function parameter shall be token-for-token identical in all declarations and re-declarationsYesAutomatedRequired
M3-9-3The underlying bit representations of floating-point values shall not be usedYesAutomatedRequired
M4-5-1Expressions with type bool shall not be used as operands to built-in operators other than the assignment operator =, the logical operators &&, ||, !, the equality operators == and !=, the unary & operator, and the conditional operatorYesAutomatedRequired
M4-5-3Character OperatorsYesAutomatedRequired
M4-10-1NULL shall not be used as an integer valueYesAutomatedRequired
M4-10-2Literal zero (0) shall not be used as the null-pointer-constant.YesAutomatedRequired
M5-0-2Limited dependence should be placed on C++ operator precedence rules in expressionsYesAutomatedAdvisory
M5-0-3A cvalue expression shall not be implicitly converted to a different underlying typeYesAutomatedRequired
M5-0-4An implicit integral conversion shall not change the signedness of the underlying typeYesAutomatedRequired
M5-0-5There shall be no implicit floating-integral conversionsYesAutomatedRequired
M5-0-6An implicit integral or floating-point conversion shall not reduce the size of the underlying typeYesAutomatedRequired
M5-0-7There shall be no explicit floating-integral conversions of a cvalue expressionYesAutomatedRequired
M5-0-8An explicit integral or floating-point conversion shall not increase the size of the underlying type of a cvalue expressionYesAutomatedRequired
M5-0-9An explicit integral conversion shall not change the signedness of the underlying type of a cvalue expressionYesAutomatedRequired
M5-0-10If the bitwise operators ~ and << are applied to an operand with an underlying type of unsigned char or unsigned short, the result shall be immediately cast to the underlying type of the operandYesAutomatedRequired
M5-0-11The plain char type shall only be used for the storage and use of character valuesYesAutomatedRequired
M5-0-12Signed char and unsigned char type shall only be used for the storage and use of numeric valuesYesAutomatedRequired
M5-0-14The first operand of a conditional-operator shall have type boolYesAutomatedRequired
M5-0-15Array indexing over pointer arithmeticYesAutomatedRequired
M5-0-16A pointer operand and any pointer resulting from pointer arithmetic using that operand shall both address elements of the same arrayYesAutomatedRequired
M5-0-17Subtraction between pointers shall only be applied to pointers that address elements of the same arrayYesAutomatedRequired
M5-0-18>, >=, <, <= shall not be applied to objects of pointer type, except where they point to the same arrayYesAutomatedRequired
M5-0-20Non-constant operands to a binary bitwise operator shall have the same underlying typeYesAutomatedRequired
M5-0-21Bitwise operators shall only be applied to operands of unsigned underlying typeYesAutomatedRequired
M5-2-3Casts from a base class to a derived class should not be performed on polymorphic typesYesAutomatedAdvisory
M5-2-6A cast shall not convert a pointer to a function to any other pointer type, including a pointer to function typeYesAutomatedRequired
M5-2-8An object with integer type or pointer to void type shall not be converted to an object with pointer type.YesAutomatedRequired
M5-2-9Pointer to Integer CastYesAutomatedRequired
M5-2-10The increment (++) and decrement (--) operators shall not be mixed with other operators in an expressionYesAutomatedRequired
M5-2-11The comma operator, && operator and the || operator shall not be overloadedYesAutomatedRequired
M5-2-12Array to Pointer DecayYesAutomatedRequired
M5-3-1Each operand of the ! operator, the logical && or the logical || operators shall have type boolYesAutomatedRequired
M5-3-2Unary Minus Operator Applied to an Expression with an Unsigned TypeYesAutomatedRequired
M5-3-3The unary & operator shall not be overloadedYesAutomatedRequired
M5-3-4Evaluation of the operand to the sizeof operator shall not contain side effectsYesAutomatedRequired
M5-8-1The right hand operand of a shift operator shall lie between zero and one less than the width in bits of the underlying type of the left hand operand.YesPartially AutomatedRequired
M5-14-1The right hand operand of a logical &&, || operators shall not contain side effectsYesAutomatedRequired
M5-17-1The semantic equivalence between a binary operator and its assignment operator form shall be preservedYesNon-automatedRequired
M5-18-1The comma operator shall not be used.YesAutomatedRequired
M6-2-1Assignment operators shall not be used in sub-expressionsYesAutomatedRequired
M6-2-2Floating-point expressions shall not be directly or indirectly tested for equality or inequalityYesPartially AutomatedRequired
M6-2-3Before preprocessing, a null statement shall only occur on a line by itself; it may be followed by a comment, provided that the first character following the null statement is a white-space characterYesAutomatedRequired
M6-3-1The statement forming the body of a switch, while, do ... while or for statement shall be a compound statementYesAutomatedRequired
M6-4-1An if ( condition ) construct shall be followed by a compound statement. The else keyword shall be followed by either a compound statement, or another if statementYesAutomatedRequired
M6-4-2All if and else if constructs shall be terminated with an else clauseYesAutomatedRequired
M6-4-3Switch Statement not Well-formedYesAutomatedRequired
M6-4-4A switch-label shall only be used when the most closely-enclosing compound statement is the body of a switch statementYesAutomatedRequired
M6-4-5An unconditional throw or break statement shall terminate every non-empty switch-clauseYesAutomatedRequired
M6-4-6The final clause of a switch statement shall be the default-clauseYesAutomatedRequired
M6-4-7The condition of a switch statement shall not have bool typeYesAutomatedRequired
M6-5-2If loop-counter is not modified by -- or ++, then, within condition, the loop-counter shall only be used as an operand to <=, <, > or >=YesAutomatedRequired
M6-5-3The loop-counter shall not be modified within condition or statementYesAutomatedRequired
M6-5-4The loop-counter shall be modified by one of: --, ++, -= n, or += n; where n remains constant for the duration of the loopYesAutomatedRequired
M6-5-5A loop-control-variable other than the loop-counter shall not be modified within condition or expressionYesAutomatedRequired
M6-5-6A loop-control-variable other than the loop-counter which is modified in statement shall have type boolYesAutomatedRequired
M6-6-1Any label referenced by a goto statement shall be declared in the same block, or in a block enclosing the goto statementYesAutomatedRequired
M6-6-2The goto statement shall jump to a label declared later in the same function bodyYesAutomatedRequired
M6-6-3Continue Statement Used in a not Well-formed For LoopYesAutomatedRequired
M7-1-2A pointer or reference parameter in a function shall be declared as pointer to const or reference to const if the corresponding object is not modifiedYesAutomatedRequired
M7-3-2The identifier main shall not be used for a function other than the global function mainYesAutomatedRequired
M7-3-3There shall be no unnamed namespaces in header files.YesAutomatedRequired
M7-3-4Using-directives shall not be used.YesAutomatedRequired
M7-3-6using-directives and using-declarations (excluding class scope or function scope using-declarations) shall not be used in header files.YesAutomatedRequired
M7-4-1Assembly Language Code Usage not DocumentedYesNon-automatedRequired
M7-4-2Assembler instructions shall only be introduced using the asm declaration.YesAutomatedRequired
M7-4-3Assembly language shall be encapsulated and isolated.YesAutomatedRequired
M7-5-1A function shall not return a reference or a pointer to an automatic variable (including parameters), defined within the function.YesNon-automatedRequired
M7-5-2The address of an object with automatic storage shall not be assigned to another object that may persist after the first object has ceased to exist.YesNon-automatedRequired
M8-0-1Single DeclarationsYesAutomatedRequired
M8-3-1Parameters in an overriding virtual function shall either use the same default arguments as the function they override, or else shall not specify any default arguments.YesAutomatedRequired
M8-4-2The identifiers used for the parameters in a re-declaration of a function shall be identical to those in the declaration.YesAutomatedRequired
M8-4-4A function identifier shall either be used to call the function or it shall be preceded by &.YesAutomatedRequired
M8-5-2Incorrect Initializer ListsYesAutomatedRequired
M9-3-1Const Member Function Returning Non-Const Pointer or ReferenceYesAutomatedRequired
M9-3-3If a member function can be made static then it shall be made static, otherwise if it can be made const then it shall be made constYesAutomatedRequired
M9-6-4Bit-field LengthYesAutomatedRequired
M10-1-1Class Derived From Virtual BasesYesAutomatedAdvisory
M10-1-2A base class shall only be declared virtual if it is used in a diamond hierarchyYesAutomatedRequired
M10-1-3An accessible base class shall not be both virtual and non-virtual in the same hierarchyYesAutomatedRequired
M10-2-1Similiar Entity Names within Multiple Inheritance YesAutomatedAdvisory
M10-3-3A virtual function shall only be overridden by a pure virtual function if it is itself declared as pure virtualYesAutomatedRequired
M11-0-1Member Data in Non-POD Class not PrivateYesAutomatedRequired
M12-1-1An object's dynamic type shall not be used from the body of its constructor or destructorYesAutomatedRequired
M14-5-3A copy assignment operator shall be declared when there is a template assignment operator with a parameter that is a generic parameterYesAutomatedRequired
M14-6-1In a class template with a dependent base, any name that may be found in that dependent base shall be referred to using a qualified-id or this->YesAutomatedRequired
M15-1-1Exception ObjectYesAutomatedRequired
M15-1-2NULL ThrowYesAutomatedRequired
M15-1-3Empty ThrowYesAutomatedRequired
M15-3-1Exceptions shall be raised only after start-up and before termination of the programYesAutomatedRequired
M15-3-3Handlers of a function-try-block implementation of a class constructor or destructor shall not reference non-static members from this class or its basesYesAutomatedRequired
M15-3-4Each exception explicitly thrown in the code shall have a handler of a compatible type in all call paths that could lead to that pointYesAutomatedRequired
M15-3-6Order of Catch Blocks with Derived ClassesYesAutomatedRequired
M16-0-1#include Directives Not Grouped TogetherYesAutomatedRequired
M16-0-2Macros shall only be #define'd or #undef'd in the global namespace.YesAutomatedRequired
M16-0-5Function-like Macro Containing Preprocessing DirectivesYesAutomatedRequired
M16-0-6In the definition of a function-like macro, each instance of a parameter shall be enclosed in parentheses, unless it is used as the operand of # or ##YesAutomatedRequired
M16-0-7Undefined macro identifiers shall not be used in #if or #elif preprocessor directives, except as operands to the defined operatorYesAutomatedRequired
M16-0-8Invalid Preprocessor DirectivesYesAutomatedRequired
M16-1-1The defined preprocessor operator shall only be used in one of the two standard formsYesAutomatedRequired
M16-2-3Include guards shall be providedYesAutomatedRequired
M16-3-1There shall be at most one occurrence of the # or ## operators in a single macro definitionYesAutomatedRequired
M16-3-2The # and ## operators should not be usedYesAutomatedAdvisory
M17-0-2The names of standard library macros and objects shall not be reusedYesAutomatedRequired
M17-0-3Standard Library Function NamesYesAutomatedRequired
M17-0-5The setjmp macro and the longjmp function shall not be usedYesAutomatedRequired
M18-0-3<cstdlib> Library FunctionsYesAutomatedRequired
M18-0-4Time Handling Functions of <ctime>YesAutomatedRequired
M18-0-5Unbounded Functions of <cstring>YesAutomatedRequired
M18-2-1The macro offsetof shall not be usedYesAutomatedRequired
M18-7-1The signal handling facilities of <csignal> shall not be usedYesAutomatedRequired
M19-3-1The error indicator errno shall not be usedYesAutomatedRequired
M27-0-1The stream input/output library <cstdio> shall not be usedYesAutomatedRequired
MEM30-CDo not access freed memoryNoHigh
MEM31-CFree dynamically allocated memory when no longer neededYesMedium
MEM33-CAllocate and copy structures containing a flexible array member dynamicallyYesLow
MEM34-COnly free memory allocated dynamicallyYesHigh
MEM35-CAllocate sufficient memory for an objectYesHigh
MEM36-CDo not modify the alignment of objects by calling realloc()NoLow
MEM50-CPPDo not access freed memoryNoHigh
MEM51-CPPProperly deallocate dynamically allocated resourcesYesHigh
MEM52-CPPDetect and handle memory allocation errorsYesHigh
MEM53-CPPExplicitly construct and destruct objects when manually managing object lifetimeNoHigh
MEM57-CPPAvoid using default operator new for over-aligned typesYesMedium
METRIC_00Program Unit Call CountYes
METRIC_01Program Unit Callby CountYes
METRIC_02Program Unit Comment to Code RatioYes
METRIC_03Program Unit Cyclomatic ComplexityYes
METRIC_04Program Unit Max LengthYes
METRIC_05Program Unit Max Nesting DepthYes
METRIC_06Program Unit Parameters CountYes
METRIC_07Program Unit Path CountYes
METRIC_08Program Unit Statement CountYes
METRIC_09Coupling Between Object ClassesYes
METRIC_11Depth of Inheritance TreeYes
METRIC_12Lack of Cohesion in MethodsYes
METRIC_13Maintainability IndexYes
MISRA04_2.12.1 Assembly language shall be encapsulated and isolated.YesRequired
MISRA04_2.22.2 only use /* commentsYesRequired
MISRA04_2.32.3 The character sequence /* shall not be used within a comment.YesRequired
MISRA04_2.42.4 Sections of code should not be "commented out"YesAdvisory
MISRA04_4.14.1 Only those escape sequences that are defined in the ISO C standard shall be usedYesRequired
MISRA04_4.24.2 Trigraphs shall not be usedYesRequired
MISRA04_5.15.1 Identifiers shall not rely on the significance of more than 31 charactersYesRequired
MISRA04_5.25.2 Shadowed IdentifiersYesRequired
MISRA04_5.35.3 A typedef name shall be a unique identifier.YesRequired
MISRA04_5.45.4 A tag name shall be a unique identifierYesRequired
MISRA04_5.55.5 No object or function identifier with static storage duration should be reusedYesAdvisory
MISRA04_5.65.6 No identifier in one name space should have the same spelling as an identifier in another name space.YesAdvisory
MISRA04_5.75.7 No identifier name should be reusedYesAdvisory
MISRA04_6.16.1 The plain char type shall only be used for the storage and use of character valuesYesRequired
MISRA04_6.26.2 Signed char and unsigned char type shall only be used for the storage and use of numeric valuesYesRequired
MISRA04_6.36.3 Typedefs that indicate size and signedness should be used in place of the basic numerical typesYesAdvisory
MISRA04_6.46.4 Bit fields shall only be defined to be of type unsigned int or signed int.YesRequired
MISRA04_6.56.5 Bit fields of signed type shall be at least 2 bits long.( Fuzzy parser )YesRequired
MISRA04_7.17.1 Octal constants (other than zero) and octal escape sequences shall not be used.YesRequired
MISRA04_8.38.3 For each function parameter the type given in the declaration and definition shall be identical, and the return types shall also be identicalYesRequired
MISRA04_8.58.5 No definitions of objects or functions in a header fileYesRequired
MISRA04_8.68.6 Functions shall be declared at file scopeYesRequired
MISRA04_8.78.7 Objects shall be local if only accessed from one functionYesRequired
MISRA04_8.88.8 An external object or function shall be declared in one and only one fileYesRequired
MISRA04_8.98.9 An identifier with external linkage shall have exactly one external definitionYesRequired
MISRA04_8.108.10 prefer internal linkage over external whenever possibleYesRequired
MISRA04_8.118.11 Use the static keyword for internal linkageYesRequired
MISRA04_8.128.12 When an array is declared with external linkage, its size shall be stated explicitly or defined implicitly by initialisationYesRequired
MISRA04_9.39.3 = construct in enumerator list shall only be used on either the first item alone, or all items explicitly.YesRequired
MISRA04_10.510.5 If the bitwise operators ~ and << are applied to an operand with an underlying type of unsigned char or unsigned short, the result shall be immediately cast to the underlying type of the operandYesRequired
MISRA04_10.610.6 A U suffix shall be applied to all constants of unsigned typeYesRequired
MISRA04_12.612.6 The operands of logical operators (&&, || and !) should be effectively Boolean. Expressions that are effectively Boolean should not be used as operands to operators other than (&&, ||, !, =, ==, != and ?:)YesAdvisory
MISRA04_12.812.8 The right-hand operand of a shift operator shall lie between zero and one less than the width in bits of the underlying type of the left-hand operand.YesRequired
MISRA04_12.1212.12 The underlying bit representations of floating-point values shall not be usedYesRequired
MISRA04_12.1312.13 The increment (++) and decrement (--) operators should not be mixed with other operators in an expressionYesAdvisory
MISRA04_13.313.3 Floating-point expressions shall not be tested for equality or inequalityYesRequired
MISRA04_13.613.6 Numeric variables being used within a for loop for iteration counting shall not be modified in the body of the loopYesRequired
MISRA04_14.114.1 There shall be no unreachable codeYesRequired
MISRA04_14.314.3 Before preprocessing, a null statement shall only occur on a line by itself; it may be followed by a comment provided that the first character following the null statement is a white-space characterYesRequired
MISRA04_14.414.4 The goto statement shall not be usedYesRequired
MISRA04_14.514.5 The continue statement shall not be usedYesRequired
MISRA04_14.614.6 For any iteration statement there shall be at most one break statement used for loop terminationYesRequired
MISRA04_14.714.7 A function shall have a single point of exit at the end of the functionYesRequired
MISRA04_14.814.8 The statement forming the body of a switch, while, do ... while or for statement shall be a compound statementYesRequired
MISRA04_14.914.9 An if (expression) construct shall be followed by a compound statement. The else keyword shall be followed by either a compound statement, or another if statementYesRequired
MISRA04_14.1014.10 All if ... else if constructs shall be terminated with an else clauseYesRequired
MISRA04_15.115.1 A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statementYesRequired
MISRA04_15.215.2 An unconditional break statement shall terminate every non-empty switch clauseYesRequired
MISRA04_15.315.3 The final clause of a switch statement shall be the default clauseYesRequired
MISRA04_15.515.5 Every switch statement shall have at least one case clauseYesRequired
MISRA04_16.116.1 Functions shall not be defined with variable numbers of arguments.YesRequired
MISRA04_16.216.2 Functions shall not call themselves, either directly or indirectly.YesRequired
MISRA04_16.316.3 All prototype parameters must have an identifier.YesRequired
MISRA04_16.416.4 use the same identifier in definition and declaration of functions.YesRequired
MISRA04_16.516.5 Functions with no parameters need explicit void keywordYesRequired
MISRA04_16.816.8 Always return a value in non-void functionsYesRequired
MISRA04_16.916.9 A function identifier shall only be used with either a preceding &, or with a parenthesised parameter list, which may be emptyYesRequired
MISRA04_17.317.3 >, >=, <, <= shall not be applied to objects of pointer type, except where they point to the same arrayYesRequired
MISRA04_17.517.5 No more than 2 levels of pointer indirectionYesAdvisory
MISRA04_17.617.6 The address of an object with automatic storage shall not be assigned to another object that may persist after the first object has ceased to exist.YesRequired
MISRA04_18.418.4 Unions shall not be usedYesRequired
MISRA04_19.119.1 #include statements in a file should only be preceded by other preprocessor directives or commentsYesAdvisory
MISRA04_19.219.2 Non-standard characters should not occur in header file names in #include directivesYesAdvisory
MISRA04_19.319.3 The #include directive shall be followed by either a <filename> or "filename" sequenceYesRequired
MISRA04_19.519.5 Macros shall not be #define'd or #undef'd within a blockYesRequired
MISRA04_19.619.6 #undef shall not be usedYesRequired
MISRA04_19.719.7 A function should be used in preference to a function-like macroYesAdvisory
MISRA04_19.919.9 Arguments to a function-like macro shall not contain tokens that look like preprocessing directivesYesRequired
MISRA04_19.1019.10 In the definition of a function-like macro, each instance of a parameter shall be enclosed in parentheses, unless it is used as the operand of # or ##YesRequired
MISRA04_19.1119.11 All macro identifiers in preprocessor directives shall be defined before use, except in #ifdef and #ifndef preprocessor directives and the defined() operatorNoRequired
MISRA04_19.1219.12 There shall be at most one occurrence of the # or ## operators in a single macro definitionYesRequired
MISRA04_19.1319.12 The # and ## operators should not be usedYesAdvisory
MISRA04_19.1419.14 The defined preprocessor operator shall only be used in one of the two standard formsYesRequired
MISRA04_19.1519.15 Precautions shall be taken in order to prevent the contents of a header file being included twiceYesRequired
MISRA04_19.1720.14 All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if, #ifdef or #ifndef directive to which they are relatedYesRequired
MISRA04_20.120.1 Reserved identifiers, macros and functions in the standard library shall not be defined, redefined or undefinedYesRequired
MISRA04_20.220.2 The names of standard library macros and objects shall not be reusedYesRequired
MISRA04_20.420.4 Dynamic heap memory allocation shall not be usedYesRequired
MISRA04_20.520.5 The error indicator "errno" shall not be usedYesRequired
MISRA04_20.620.6 The macro offsetof, in library <stddef.h>, shall not be usedYesRequired
MISRA04_20.720.7 The setjmp macro and the longjmp function shall not be usedYesRequired
MISRA04_20.820.8 The signal handling facilities of <signal.h> shall not be usedYesRequired
MISRA04_20.920.9 The input output library <stdio.h> shall not be used in production codeYesRequired
MISRA04_20.1020.10 The library functions atof, atoi and atol from library <stdlib.h> shall not be usedYesRequired
MISRA04_20.1120.11 The library functions abort, exit, getenv and system from library <stdlib.h> shall not be usedYesRequired
MISRA04_20.1220.12 The time handling functions of library <time.h> shall not be usedYesRequired
MISRA04_21.121.1 Minimisation of run-time failures shall be ensured by the use of at least one of: (a) static analysis tools/techniques; (b) dynamic analysis tools/techniques; (c) explicit coding of checks to handle run-time faults.YesRequired
MISRA08_0-1-10-1-1 A project shall not contain unreachable codeYesRequired
MISRA08_0-1-20-1-2 Infeasible PathsYesRequired
MISRA08_0-1-30-1-3 A project shall not contain unused variablesYesRequired
MISRA08_0-1-40-1-4 A project shall not contain non-volatile POD variables having only one use.YesRequired
MISRA08_0-1-50-1-5 A project shall not contain unused type declarationsYesRequired
MISRA08_0-1-70-1-7 The value returned by a function having a non-void return type that is not an overloaded operator shall always be usedYesRequired
MISRA08_0-1-80-1-8 All functions with void return type shall have external side effect(s)YesRequired
MISRA08_0-1-100-1-10 All defined functions calledYesRequired
MISRA08_0-1-110-1-11 Unused Parameters in Non-virtual FunctionsYesRequired
MISRA08_0-1-120-1-12 There shall be no unused parameters (named or unnamed) in the set of parameters for a virtual function and all the functions that override itYesRequired
MISRA08_2-3-12-3-1 Trigraphs shall not be usedYesRequired
MISRA08_2-5-12-5-1 Digraphs shall not be usedYesAdvisory
MISRA08_2-7-12-7-1 The character sequence /* shall not be used within a C-style comment.YesRequired
MISRA08_2-7-22-7-2 Sections of code shall not be "commented out"YesRequired
MISRA08_2-10-12-10-1 Different identifiers shall be typographically unambiguousYesRequired
MISRA08_2-10-22-10-2 Shadowed IdentifiersYesRequired
MISRA08_2-10-32-10-3 A typedef name shall be a unique identifierYesRequired
MISRA08_2-10-42-10-4 A class, union or enum name (including qualification, if any) shall be a unique identifierYesRequired
MISRA08_2-10-52-10-5 The identifier name of a non-member object or function with static storage duration should not be reusedYesAdvisory
MISRA08_2-13-12-13-1 escape sequences are standardizedYesRequired
MISRA08_2-13-22-13-2 Octal constants (other than zero) and octal escape sequences (other than "\0" ) shall not be used.YesRequired
MISRA08_2-13-32-13-3 A "U" suffix shall be applied to all octal or hexadecimal integer literals of unsigned type.YesRequired
MISRA08_2-13-42-13-4 Literal suffixes shall be upper caseYesRequired
MISRA08_2-13-52-13-5 Narrow and wide string literals shall not be concatenatedYesRequired
MISRA08_3-1-13-1-1 It shall be possible to include any header file in multiple translation units without violating the One Definition RuleYesRequired
MISRA08_3-1-23-1-2 Functions shall not be declared at block scopeYesRequired
MISRA08_3-1-33-1-3 When an array is declared, its size shall either be stated explicitly or defined implicitly by initializationYesRequired
MISRA08_3-2-13-2-1 All declarations of an object or function shall have compatible typesYesRequired
MISRA08_3-2-23-2-2 The One Definition RuleYesRequired
MISRA08_3-2-33-2-3 A type, object or function that is used in multiple translation units shall be declared in one and only one fileYesRequired
MISRA08_3-2-43-2-4 An identifier with external linkage shall have exactly one definitionYesRequired
MISRA08_3-3-13-3-1 Objects or functions with external linkage shall be declared in a header fileYesRequired
MISRA08_3-3-23-3-2 If a function has internal linkage then all redeclarations shall include the static storage class specifierYesRequired
MISRA08_3-4-13-4-1 Declarations at Lowest ScopeYesRequired
MISRA08_3-9-13-9-1 The types used for an object, a function return type, or a function parameter shall be token-for-token identical in all declarations and re-declarationsYesRequired
MISRA08_3-9-23-9-2 Typedefs that indicate size and signedness should be used in place of the basic numerical typesYesAdvisory
MISRA08_3-9-33-9-3 The underlying bit representations of floating-point values shall not be usedYesRequired
MISRA08_4-5-14-5-1 Expressions with type bool shall not be used as operands to built-in operators other than the assignment operator =, the logical operators &&, ||, !, the equality operators == and !=, the unary & operator, and the conditional operatorYesRequired
MISRA08_4-5-24-5-2 Expressions with type enum shall not be used as operands to built-in operators other than the subscript operator [ ], the assignment operator =, the equality operators == and !=, the unary & operator, and the relational operators <, <=, >, >=YesRequired
MISRA08_4-5-34-5-3 Character OperatorsYesRequired
MISRA08_4-10-14-10-1 NULL shall not be used as an integer valueYesRequired
MISRA08_4-10-24-10-2 Literal zero (0) shall not be used as the null-pointer-constant.YesRequired
MISRA08_5-0-25-0-2 Limited dependence should be placed on C++ operator precedence rules in expressionsYesAdvisory
MISRA08_5-0-35-0-3 A cvalue expression shall not be implicitly converted to a different underlying typeYesRequired
MISRA08_5-0-45-0-4 An implicit integral conversion shall not change the signedness of the underlying typeYesRequired
MISRA08_5-0-55-0-5 There shall be no implicit floating-integral conversionsYesRequired
MISRA08_5-0-65-0-6 An implicit integral or floating-point conversion shall not reduce the size of the underlying typeYesRequired
MISRA08_5-0-75-0-7 There shall be no explicit floating-integral conversions of a cvalue expressionYesRequired
MISRA08_5-0-85-0-8 An explicit integral or floating-point conversion shall not increase the size of the underlying type of a cvalue expressionYesRequired
MISRA08_5-0-95-0-9 An explicit integral conversion shall not change the signedness of the underlying type of a cvalue expressionYesRequired
MISRA08_5-0-105-0-10 If the bitwise operators ~ and << are applied to an operand with an underlying type of unsigned char or unsigned short, the result shall be immediately cast to the underlying type of the operandYesRequired
MISRA08_5-0-115-0-11 The plain char type shall only be used for the storage and use of character valuesYesRequired
MISRA08_5-0-125-0-12 Signed char and unsigned char type shall only be used for the storage and use of numeric valuesYesRequired
MISRA08_5-0-145-0-14 The first operand of a conditional-operator shall have type boolYesRequired
MISRA08_5-0-175-0-17 Subtraction between pointers shall only be applied to pointers that address elements of the same arrayYesRequired
MISRA08_5-0-185-0-18 >, >=, <, <= shall not be applied to objects of pointer type, except where they point to the same arrayYesRequired
MISRA08_5-0-195-0-19 No more than 2 levels of pointer indirectionYesRequired
MISRA08_5-0-205-0-20 Non-constant operands to a binary bitwise operator shall have the same underlying typeYesRequired
MISRA08_5-0-215-0-21 Bitwise operators shall only be applied to operands of unsigned underlying typeYesRequired
MISRA08_5-2-35-2-3 Casts from a base class to a derived class should not be performed on polymorphic typesYesAdvisory
MISRA08_5-2-55-2-5 A cast shall not remove any const or volatile qualification from the type of a pointer or referenceYesRequired
MISRA08_5-2-65-2-6 A cast shall not convert a pointer to a function to any other pointer type, including a pointer to function typeYesRequired
MISRA08_5-2-85-2-8 An object with integer type or pointer to void type shall not be converted to an object with pointer type.YesRequired
MISRA08_5-2-95-2-9 Pointer to Integer CastYesAdvisory
MISRA08_5-2-105-2-10 The increment (++) and decrement (--) operators shall not be mixed with other operators in an expressionYesAdvisory
MISRA08_5-2-115-2-11 The comma operator, && operator and the || operator shall not be overloadedYesRequired
MISRA08_5-2-125-2-12 Array to Pointer DecayYesRequired
MISRA08_5-3-15-3-1 Each operand of the ! operator, the logical && or the logical || operators shall have type boolYesRequired
MISRA08_5-3-35-3-3 The unary & operator shall not be overloadedYesRequired
MISRA08_5-3-45-3-4 Evaluation of the operand to the sizeof operator shall not contain side effectsYesRequired
MISRA08_5-8-15-8-1 The right hand operand of a shift operator shall lie between zero and one less than the width in bits of the underlying type of the left hand operand.YesRequired
MISRA08_6-2-26-2-2 Floating-point expressions shall not be directly or indirectly tested for equality or inequalityYesRequired
MISRA08_6-2-36-2-3 Before preprocessing, a null statement shall only occur on a line by itself; it may be followed by a comment, provided that the first character following the null statement is a white-space characterYesRequired
MISRA08_6-3-16-3-1 The statement forming the body of a switch, while, do ... while or for statement shall be a compound statementYesRequired
MISRA08_6-4-16-4-1 An if ( condition ) construct shall be followed by a compound statement. The else keyword shall be followed by either a compound statement, or another if statementYesRequired
MISRA08_6-4-26-4-2 All if ... else if constructs shall be terminated with an else clauseYesRequired
MISRA08_6-4-46-4-4 A switch-label shall only be used when the most closely-enclosing compound statement is the body of a switch statementYesRequired
MISRA08_6-4-56-4-5 An unconditional throw or break statement shall terminate every non-empty switch-clauseYesRequired
MISRA08_6-4-66-4-6 The final clause of a switch statement shall be the default-clauseYesRequired
MISRA08_6-4-86-4-8 Every switch statement shall have at least one case clauseYesRequired
MISRA08_6-5-16-5-1 A for loop shall contain a single loop-counter which shall not have floating-point typeYesRequired
MISRA08_6-5-26-5-2 If loop-counter is not modified by -- or ++, then, within condition, the loop-counter shall only be used as an operand to <=, <, > or >=YesRequired
MISRA08_6-5-36-5-3 The loop-counter shall not be modified within condition or statementYesRequired
MISRA08_6-5-46-5-4 The loop-counter shall be modified by one of: --, ++, -= n, or += n; where n remains constant for the duration of the loopYesRequired
MISRA08_6-5-56-5-5 A loop-control-variable other than the loop-counter shall not be modified within condition or expressionYesRequired
MISRA08_6-5-66-5-6 A loop-control-variable other than the loop-counter which is modified in statement shall have type boolYesRequired
MISRA08_6-6-16-6-1 Any label referenced by a goto statement shall be declared in the same block, or in a block enclosing the goto statementYesRequired
MISRA08_6-6-26-6-2 The goto statement shall jump to a label declared later in the same function bodyYesRequired
MISRA08_6-6-46-6-4 For any iteration statement there shall be no more than one break or goto statement used for loop terminationYesRequired
MISRA08_6-6-56-6-5 A function shall have a single point of exit at the end of the functionYesRequired
MISRA08_7-1-17-1-1 A variable which is not modified shall be const qualifiedYesRequired
MISRA08_7-1-27-1-2 A pointer or reference parameter in a function shall be declared as pointer to const or reference to const if the corresponding object is not modifiedYesRequired
MISRA08_7-2-17-2-1 An expression with enum underlying type shall only have values corresponding to the enumerators of the enumerationYesRequired
MISRA08_7-3-27-3-2 The identifier main shall not be used for a function other than the global function mainYesRequired
MISRA08_7-3-37-3-3 There shall be no unnamed namespaces in header files.YesRequired
MISRA08_7-3-47-3-4 Using-directives shall not be used.YesRequired
MISRA08_7-3-57-3-5 Multiple declarations for an identifier in the same namespace shall not straddle a using-declaration for that identifierYesRequired
MISRA08_7-3-67-3-6 using-directives and using-declarations (excluding class scope or function scope using-declarations) shall not be used in header files.YesRequired
MISRA08_7-4-27-4-2 Assembler instructions shall only be introduced using the asm declaration.YesRequired
MISRA08_7-4-37-4-3 Assembly language shall be encapsulated and isolated.YesRequired
MISRA08_7-5-17-5-1 A function shall not return a reference or a pointer to an automatic variable (including parameters), defined within the function.YesRequired
MISRA08_7-5-27-5-2 The address of an object with automatic storage shall not be assigned to another object that may persist after the first object has ceased to exist.YesRequired
MISRA08_7-5-47-5-4 Functions should not call themselves, either directly or indirectly.YesAdvisory
MISRA08_8-0-18-0-1 Single DeclarationsYesRequired
MISRA08_8-3-18-3-1 Parameters in an overriding virtual function shall either use the same default arguments as the function they override, or else shall not specify any default arguments.YesRequired
MISRA08_8-4-18-4-1 Functions shall not be defined using the ellipsis notationYesRequired
MISRA08_8-4-28-4-2 Use the same identifier in definition and declaration of functions.YesRequired
MISRA08_8-4-38-4-3 Always return a value in non-void functionsYesRequired
MISRA08_8-4-48-4-4 A function identifier shall either be used to call the function or it shall be preceded by &YesRequired
MISRA08_8-5-18-5-1 All variables shall have a defined value before they are usedYesRequired
MISRA08_8-5-28-5-2 Incorrect Initializer ListsYesAutomatedRequired
MISRA08_8-5-38-5-3 The = construct in enumerator list shall only be used on either the first item alone, or all items explicitly.YesRequired
MISRA08_9-3-19-3-1 Const member functions shall not return non-const pointers or references to class-dataYesRequired
MISRA08_9-3-29-3-2 Member functions shall not return non-const handles to class-dataYesRequired
MISRA08_9-3-39-3-3 If a member function can be made static then it shall be made static, otherwise if it can be made const then it shall be made constYesRequired
MISRA08_9-5-19-5-1 Unions shall not be usedYesRequired
MISRA08_9-6-29-6-2 Bool, Unsigned, or Signed Bit-fieldsYesRequired
MISRA08_9-6-39-6-3 Enum Bit-fieldsYesRequired
MISRA08_9-6-49-6-4 (Fuzzy parser) Named bit-fields with signed integer type shall have a length of more than one bitYesRequired
MISRA08_10-1-110-1-1 Classes should not be derived from virtual basesYesAdvisory
MISRA08_10-1-210-1-2 A base class shall only be declared virtual if it is used in a diamond hierarchyYesRequired
MISRA08_10-1-310-1-3 An accessible base class shall not be both virtual and non-virtual in the same hierarchyYesRequired
MISRA08_10-3-110-3-1 There shall be no more than one definition of each virtual function on each path through the inheritance hierarchyYesRequired
MISRA08_10-3-210-3-2 Each overriding virtual function shall be declared with the virtual keyword.YesRequired
MISRA08_10-3-310-3-3 A virtual function shall only be overridden by a pure virtual function if it is itself declared as pure virtualYesRequired
MISRA08_11-0-111-0-1 Member data in non-POD class types shall be privateYesRequired
MISRA08_12-1-112-1-1 An object's dynamic type shall not be used from the body of its constructor or destructorYesRequired
MISRA08_12-1-212-1-2 Explicitly call all immediate and virtual base classesYesAdvisory
MISRA08_12-1-312-1-3 All constructors that are callable with a single argument of fundamental type shall be declared explicit.YesRequired
MISRA08_12-8-112-8-1 A copy constructor shall only initialize its base classes and the non-static members of the class of which it is a memberYesRequired
MISRA08_14-5-214-5-2 A copy constructor shall be declared when there is a template constructor with a single parameter that is a generic parameterYesRequired
MISRA08_14-5-314-5-3 A copy assignment operator shall be declared when there is a template assignment operator with a parameter that is a generic parameterYesRequired
MISRA08_14-7-114-7-1 All class templates, function templates, class template member functions and class template static members shall be instantiated at least onceYesRequired
MISRA08_14-8-114-8-1 Overloaded function templates shall not be explicitly specializedYesRequired
MISRA08_15-0-215-0-2 An exception object should not have pointer typeYesAdvisory
MISRA08_15-1-115-1-1 The assignment-expression of a throw statement shall not itself cause an exception to be thrownYesRequired
MISRA08_15-1-215-1-2 NULL shall not be thrown explicitlyYesRequired
MISRA08_15-1-315-1-3 An empty throw (throw;) shall only be used in the compound-statement of a catch handlerYesRequired
MISRA08_15-3-115-3-1 Exceptions shall be raised only after start-up and before termination of the programYesRequired
MISRA08_15-3-215-3-2 There should be at least one exception handler to catch all otherwise unhandled exceptionsYesAdvisory
MISRA08_15-3-315-3-3 Members in function-try-blocks in constructors or destructorsYesRequired
MISRA08_15-3-515-3-5 A class type exception shall always be caught by referenceYesRequired
MISRA08_15-3-615-3-6 Order of Catch Blocks with Derived ClassesYesRequired
MISRA08_15-5-115-5-1 A class destructor shall not exit with an exceptionYesRequired
MISRA08_15-5-215-5-2 Exceptions thrown shall be the type indicated by the functionYesRequired
MISRA08_16-0-116-0-1 #include directives in a file shall only be preceded by other preprocessor directives or commentsYesRequired
MISRA08_16-0-216-0-2 Macros shall only be #define'd or #undef'd in the global namespaceYesRequired
MISRA08_16-0-316-0-3 #undef shall not be usedYesRequired
MISRA08_16-0-416-0-4 Function-like macros shall not be definedYesRequired
MISRA08_16-0-516-0-5 Arguments to a function-like macro shall not contain tokens that look like preprocessing directivesYesRequired
MISRA08_16-0-616-0-6 In the definition of a function-like macro, each instance of a parameter shall be enclosed in parentheses, unless it is used as the operand of # or ##YesRequired
MISRA08_16-0-716-0-7 Undefined macro identifiers shall not be used in #if or #elif preprocessor directives, except as operands to the defined operatorYesRequired
MISRA08_16-0-816-0-8 Invalid Preprocessor DirectivesYesRequired
MISRA08_16-1-116-1-1 The defined preprocessor operator shall only be used in one of the two standard formsYesRequired
MISRA08_16-2-116-2-1 The pre-processor shall only be used for file inclusion and include guardsYesRequired
MISRA08_16-2-216-2-2 C++ macros shall only be used for include guards, type qualifiers, or storage class specifiersYesRequired
MISRA08_16-2-316-2-3 Include guards shall be providedYesRequired
MISRA08_16-2-416-2-4 The ', ", /* or // characters shall not occur in a header file nameYesRequired
MISRA08_16-2-516-2-5 The backslash character should not occur in a header file nameYesAdvisory
MISRA08_16-3-116-3-1 There shall be at most one occurrence of the # or ## operators in a single macro definitionYesRequired
MISRA08_16-3-216-3-2 The # and ## operators should not be usedYesAdvisory
MISRA08_17-0-117-0-1 Reserved identifiers, macros and functions in the standard library shall not be defined, redefined or undefinedYesRequired
MISRA08_17-0-217-0-2 The names of standard library macros and objects shall not be reusedYesRequired
MISRA08_17-0-317-0-3 Standard Library Function NamesYesRequired
MISRA08_17-0-517-0-5 The setjmp macro and the longjmp function shall not be usedYesRequired
MISRA08_18-0-118-0-1 The C library shall not be usedYesRequired
MISRA08_18-0-218-0-2 The library functions atof, atoi and atol from library <cstdlib> shall not be usedYesRequired
MISRA08_18-0-318-0-3 The library functions abort, exit, getenv and system from library <cstdlib> shall not be usedYesRequired
MISRA08_18-0-418-0-4 The time handling functions of library <ctime> shall not be usedYesRequired
MISRA08_18-0-518-0-5 Unbounded Functions of <cstring>YesRequired
MISRA08_18-2-118-2-1 The macro offsetof shall not be used.YesRequired
MISRA08_18-4-118-4-1 Dynamic heap memory allocation shall not be used.YesRequired
MISRA08_18-7-118-7-1 The signal handling facilities of <csignal> shall not be usedYesRequired
MISRA08_19-3-119-3-1 The error indicator "errno" shall not be used.YesRequired
MISRA08_27-0-127-0-1 The stream input/output library <cstdio> shall not be usedYesRequired
MISRA12_1.11.1 The program shall contain no violations of the standard C syntax and constraints, and shall not exceed the implementation's translation limitsYesRequired
MISRA12_1.21.2 Language extensions should not be usedNoAdvisory
MISRA12_1.31.3 There shall be no occurrence of undefined or critical unspecified behaviourNoRequired
MISRA12_2.12.1 A project shall not contain unreachable codeYesRequired
MISRA12_2.22.2 There shall be no dead codeNoRequired
MISRA12_2.32.3 A project should not contain unused type declarationsYesAdvisory
MISRA12_2.42.4 A project should not contain unused tag declarationsYesAdvisory
MISRA12_2.52.5 A project should not contain unused macro declarationsYesAdvisory
MISRA12_2.62.6 Unused LabelsYesRequired
MISRA12_2.72.7 There should be no unused parameters in functionsYesAdvisory
MISRA12_3.13.1 The character sequences /* and // shall not be used within a commentYesRequired
MISRA12_3.23.2 Line-splicing shall not be used in // commentsYesRequired
MISRA12_4.14.1 Octal and Hexadecimal SequencesYesRequired
MISRA12_4.24.2 Trigraphs should not be usedYesAdvisory
MISRA12_5.15.1 External identifiers shall be distinctYesRequired
MISRA12_5.25.2 Identifiers declared in the same scope and name space shall be distinctYesRequired
MISRA12_5.35.3 Shadowed IdentifiersYesRequired
MISRA12_5.45.4 Macro identifiers shall be distinctYesRequired
MISRA12_5.55.5 Identifiers shall be distinct from macro namesYesRequired
MISRA12_5.65.6 A typedef name shall be a unique identifierYesRequired
MISRA12_5.75.7 A tag name shall be a unique identifierYesRequired
MISRA12_5.85.8 Identifiers that define objects or functions with external linkage shall be uniqueYesRequired
MISRA12_5.95.9 Identifiers that define objects or functions with internal linkage should be uniqueYesAdvisory
MISRA12_6.16.1 Bit-fields shall only be declared with an appropriate typeYesRequired
MISRA12_6.26.2 Single-bit named bit fields shall not be of a signed typeYesRequired
MISRA12_7.17.1 Octal constants shall not be usedYesRequired
MISRA12_7.27.2 A u or U suffix shall be applied to all integer constants that are represented in an unsigned typeYesRequired
MISRA12_7.37.3 The lowercase character L shall not be used in a literal suffixYesRequired
MISRA12_7.47.4 A string literal shall not be assigned to an object unless the object's type is "pointer to const-qualified char"NoRequired
MISRA12_8.18.1 Types shall be explicitly specifiedYesRequired
MISRA12_8.28.2 Use Named Parameters and Prototype FormYes
MISRA12_8.38.3 All declarations of an object or function shall use the same names and type qualifiersYesRequired
MISRA12_8.48.4 A compatible declaration shall be visible when an object or function with external linkage is definedYesRequired
MISRA12_8.58.5 An external object or function shall be declared once in one and only one fileYesRequired
MISRA12_8.68.6 An identifier with external linkage shall have exactly one external definitionYesRequired
MISRA12_8.78.7 Functions and objects should not be defined with external linkage if they are referenced in only one translation unitYesAdvisory
MISRA12_8.88.8 Use the static keyword for internal linkageYesRequired
MISRA12_8.98.9 Objects shall be local if only accessed from one functionYesAdvisory
MISRA12_8.108.10 Non-static Inline FunctionsYesRequired
MISRA12_8.118.11 When an array with external linkage is declared, its size should be explicitly specifiedYesAdvisory
MISRA12_8.128.12 Within an enumerator list, the value of an implicitly-specified enumeration constant shall be uniqueYesRequired
MISRA12_8.138.13 A pointer should point to a const-qualified type whenever possibleNoAdvisory
MISRA12_8.148.14 The restrict type qualifier shall not be usedYesRequired
MISRA12_9.19.1 The value of an object with automatic storage duration shall not be read before it has been setYesMandatory
MISRA12_9.29.2 The initializer for an aggregate or union shall be enclosed in bracesYesRequired
MISRA12_9.39.3 Arrays shall not be partially initializedYesRequired
MISRA12_9.49.4 An element of an object shall not be initialized more than onceYesRequired
MISRA12_9.59.5 Where designated initializers are used to initialize an array object the size of the array shall be specified explicitlyYesRequired
MISRA12_10.110.1 Operands shall not be of an inappropriate essential typeYesRequired
MISRA12_10.210.2 Expressions of essentially character type shall not be used inappropriately in addition and subtraction operationsNoRequired
MISRA12_10.310.3 The value of an expression shall not be assigned to an object with a narrower essential type or of a different essential type categoryNoRequired
MISRA12_10.410.4 Both operands of an operator in which the usual arithmetic conversions are performed shall have the same essential type categoryYesRequired
MISRA12_10.510.5 The value of an expression should not be cast to an inappropriate essential typeYesAdvisory
MISRA12_10.610.6 The value of a composite expression shall not be assigned to an object with wider essential typeYesRequired
MISRA12_10.710.7 If a composite expression is used as one operand of an operator in which the usual arithmetic conversions are performed then the other operand shall not have wider essential typeNoRequired
MISRA12_10.810.8 The value of a composite expression shall not be cast to a different essential type category or a wider essential typeYesRequired
MISRA12_11.111.1 Conversions shall not be performed between a pointer to a function and any other typeYesRequired
MISRA12_11.211.2 Conversions shall not be performed between a pointer to an incomplete type
and any other type
YesRequired
MISRA12_11.311.3 A cast shall not be performed between a pointer to object type and a pointer to a different object typeYesRequired
MISRA12_11.411.4 A conversion should not be performed between a pointer to object and an integer typeYesRequired
MISRA12_11.511.5 A conversion should not be performed from pointer to void into pointer to objectYesAdvisory
MISRA12_11.611.6 A cast shall not be performed between pointer to void and an arithmetic typeYesRequired
MISRA12_11.711.7 A cast shall not be performed between pointer to object and a non-integer arithmetic typeYesRequired
MISRA12_11.811.8 A cast shall not remove any const or volatile qualification from the type pointed to by a pointerYesRequired
MISRA12_11.911.9 The macro NULL shall be the only permitted form of integer null pointer constantYesRequired
MISRA12_12.112.1 The precedence of operators within expressions should be made explicitNoAdvisory
MISRA12_12.212.2 The right hand operand of a shift operator shall lie between zero and one less than the width in bits of the underlying type of the left hand operand.YesRequired
MISRA12_12.312.3 The comma operator shall not be used.YesAdvisory
MISRA12_12.412.4 Evaluation of constant expressions should not lead to unsigned integer wrap-aroundNoAdvisory
MISRA12_13.113.1 Initializer lists shall not contain persistent side effectsYesRequired
MISRA12_13.213.2 The value of an expression and its persistent side effects shall be the same under all permitted evaluation ordersNoRequired
MISRA12_13.313.3 A full expression containing an increment (++) or decrement (--) operator should have no other potential side effects other than that caused by the increment or decrement operatorYesAdvisory
MISRA12_13.413.4 The result of an assignment operator should not be usedYesAdvisory
MISRA12_13.513.5 The right hand operand of a logical && or || operator shall not contain persistent side effectsYesRequired
MISRA12_13.613.6 The operand of the sizeof operator shall not contain any expression which has potential side effectsYesMandatory
MISRA12_14.114.1 A loop counter shall not have essentially floating typeYesRequired
MISRA12_14.214.2 A for loop shall be well-formedNoRequired
MISRA12_14.314.3 Controlling expressions shall not be invariantNoRequired
MISRA12_14.414.4 The controlling expression of an if statement and the controlling expression of an iteration-statement shall have essentially Boolean typeYesRequired
MISRA12_15.115.1 The goto statement should not be usedYesAdvisory
MISRA12_15.215.2 The goto statement shall jump to a label declared later in the same functionYesRequired
MISRA12_15.315.3 Any label referenced by a goto statement shall be declared in the same block, or in any block enclosing the goto statementYesRequired
MISRA12_15.415.4 There should be no more than one break or goto statement used to terminate any iteration statementYesAdvisory
MISRA12_15.515.5 A function should have a single point of exit at the endYesAdvisory
MISRA12_15.615.6 The body of an iteration-statement or a selection-statement shall be a compound-statement YesRequired
MISRA12_15.715.7 All if ... else if constructs shall be terminated with an else statementYesRequired
MISRA12_16.1Switch Statement not Well-formedYesRequired
MISRA12_16.216.2 A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statementYesRequired
MISRA12_16.316.3 An unconditional break statement shall terminate every switch-clauseYesRequired
MISRA12_16.416.4 Every switch statement shall have a default labelYesRequired
MISRA12_16.516.5 A default label shall appear as either the first or the last switch label of a switch statementYesRequired
MISRA12_16.616.6 Every switch statement shall have at least two switch-clausesYesRequired
MISRA12_16.716.7 A switch-expression shall not have essentially Boolean typeNoRequired
MISRA12_17.117.1 The features of <stdarg.h> shall not be usedYesRequired
MISRA12_17.217.2 Functions shall not call themselves, either directly or indirectlyYesRequired
MISRA12_17.317.3 A function shall not be declared implicitlyYesMandatory
MISRA12_17.417.4 Always return a value in non-void functionsYesRequired
MISRA12_17.517.5 The function argument corresponding to a parameter declared to have an array type shall have an appropriate number of elementsNoAdvisory
MISRA12_17.617.6 The declaration of an array parameter shall not contain the static keyword between the [ ]YesMandatory
MISRA12_17.717.7 The value returned by a function having non-void return type shall be usedYesRequired
MISRA12_17.817.8 A function parameter should not be modifiedYesAdvisory
MISRA12_18.118.1 A pointer resulting from arithmetic on a pointer operand shall addressNoRequired
MISRA12_18.218.2 Subtraction between pointers shall only be applied to pointers that address elements of the same arrayYesRequired
MISRA12_18.318.3 The relational operators >, >=, < and <= shall not be applied to objects of pointer type except where they point into the same objectYesRequired
MISRA12_18.418.4 The +, -, += and -= operators should not be applied to an expression of pointer typeNoAdvisory
MISRA12_18.518.5 Declarations should contain no more than two levels of pointer nestingNoAdvisory
MISRA12_18.618.6 The address of an object with automatic storage shall not be copied to another object that persists after the first object has ceased to existYesRequired
MISRA12_18.718.7 Flexible array members shall not be declaredYesRequired
MISRA12_18.818.8 Variable-length array types shall not be usedNoRequired
MISRA12_19.119.1 An object shall not be assigned or copied to an overlapping objectNoMandatory
MISRA12_19.219.2 The Union keyword should not be usedYesAdvisory
MISRA12_20.120.1 #include directives should only be preceded by preprocessor directives or commentsYesAdvisory
MISRA12_20.220.2 The ', " or backslash characters and the /* or // character sequences shall not occur in a header file nameYesRequired
MISRA12_20.320.3 The #include directive shall be followed by either a <filename> or "filename" sequenceYesRequired
MISRA12_20.420.4 A macro shall not be defined with the same name as a keywordYesRequired
MISRA12_20.520.5 #undef should not be usedYesAdvisory
MISRA12_20.620.6 Tokens that look like a preprocessing directive shall not occur within a macro argumentYesRequired
MISRA12_20.720.7 Expressions resulting from the expansion of macro parameters shall be enclosed in parenthesesNoRequired
MISRA12_20.820.8 The controlling expression of a #if or #elif preprocessing directive shall evaluate to 0 or 1NoRequired
MISRA12_20.920.9 All identifiers used in the controlling expression of #if or #elif preprocessing directives shall be #define'd before evaluationNoRequired
MISRA12_20.1020.10 The # and ## operators should not be usedYesAdvisory
MISRA12_20.1120.11 A macro parameter immediately following a # operator shall not immediately be followed by a ## operatorYesRequired
MISRA12_20.1220.12 A macro parameter used as an operand to the # or ## operators, which is itself subject to further macro replacement, shall only be used as an operand to these operatorsNoRequired
MISRA12_20.1320.13 Invalid Preprocessor DirectivesYesRequired
MISRA12_20.1420.14 All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if, #ifdef or #ifndef directive to which they are relatedYesRequired
MISRA12_21.121.1 #define and #undef shall not be used on a reserved identifier or reserved macro nameYesRequired
MISRA12_21.221.2 Reserved Identifiers or MacrosYesRequired
MISRA12_21.321.3 The memory allocation and deallocation functions of &lt;stdlib.h&gt; shall not be usedYesRequired
MISRA12_21.421.4 The standard header file <setjmp.h> shall not be usedYesRequired
MISRA12_21.521.5 The standard header file signal.h shall not be usedYesRequired
MISRA12_21.621.6 The Standard Library input/output functions shall not be usedYesRequired
MISRA12_21.721.7 The atof, atoi, atol and atoll functions of <stdlib.h> shall not be usedYesRequired
MISRA12_21.821.8 The library functions abort, exit, getenv and system of <stdlib.h> shall not be usedYesRequired
MISRA12_21.921.9 The library functions bsearch and qsort of <stdlib.h> shall not be usedYesRequired
MISRA12_21.1021.10 The Standard Library time and date functions shall not be usedYesRequired
MISRA12_21.1121.11 The standard header file <tgmath.h> shall not be usedYesRequired
MISRA12_21.1221.12 The exception handling features of <fenv.h> should not be usedYesAdvisory
MISRA12_22.122.1 All resources obtained dynamically by means of Standard Library functions shall be explicitly releasedNoRequired
MISRA12_22.222.2 A block of memory shall only be freed if it was allocated by means of a Standard Library functionNoMandatory
MISRA12_22.322.3 The same file shall not be open for read and write access at the same time on different streamsNoRequired
MISRA12_22.422.4 There shall be no attempt to write to a stream which has been opened as read-onlyNoMandatory
MISRA12_22.522.5 A pointer to a FILE object shall not be dereferencedNoMandatory
MISRA12_22.622.6 The value of a pointer to a FILE shall not be used after the associated stream has been closedNoMandatory
MISRA12_DIR_1.1Directive 1.1 Any implementation-defined behaviour on which the output of the program depends shall be documented and understoodNoRequired
MISRA12_DIR_2.1Directive 2.1 All source files shall compile without any compilation errorsYesRequired
MISRA12_DIR_3.1Directive 3.1 All code shall be traceable to documented requirementsNoRequired
MISRA12_DIR_4.1Directive 4.1 Run-time failures shall be minimizedNoRequired
MISRA12_DIR_4.2Directive 4.2 All usage of assembly language should be documentedNoAdvisory
MISRA12_DIR_4.3Directive 4.3 Assembly language shall be encapsulated and isolated.YesRequired
MISRA12_DIR_4.4Directive 4.4 Sections of code should not be "commented out"YesAdvisory
MISRA12_DIR_4.5Directive 4.5 Identifiers in the same name space with overlapping visibility should be typographically unambiguousYesAdvisory
MISRA12_DIR_4.6Directive 4.6 Typedefs that indicate size and signedness should be used in place of the basic numerical typesYesAdvisory
MISRA12_DIR_4.7Directive 4.7 If a function generates error information, then that error information shall be testedNoRequired
MISRA12_DIR_4.8Directive 4.8 If a pointer to a structure or union is never dereferenced within a translation unit, then the implementation of the object should be hiddenYesAdvisory
MISRA12_DIR_4.9Directive 4.9 A function should be used in preference to a function-like macro where they are interchangeableNoAdvisory
MISRA12_DIR_4.10Directive 4.10 Precautions shall be taken in order to prevent the contents of a header file being included more than onceYesRequired
MISRA12_DIR_4.11Directive 4.11 The validity of values passed to library functions shall be checkedNoRequired
MISRA12_DIR_4.12Directive 4.12 Dynamic memory allocation shall not be usedYesRequired
MISRA12_DIR_4.13Directive 4.13 Functions which are designed to provide operations on a resource should be called in an appropriate sequenceNoAdvisory
MISRA23_0.0.10.0.1 A function shall not contain unreachable statementsYesRequired
MISRA23_0.1.20.1.2 The value returned by a function shall be usedYesRequired
MISRA23_0.2.10.2.1 Variables with limited visibility should be used at least onceYesAdvisory
MISRA23_0.2.20.2.2 A named function parameter shall be used at least onceYesRequired
MISRA23_0.2.30.2.3 Types with limited visibility should be used at least onceYesAdvisory
MISRA23_0.2.40.2.4 Functions with limited visibility should be used at least onceYesAdvisory
MISRA23_1.11.1 The program shall contain no violations of the standard C syntax and constraints, and shall not exceed the implementation's translation limitsYesRequired
MISRA23_1.21.2 Language extensions should not be usedNoAdvisory
MISRA23_1.31.3 There shall be no occurrence of undefined or critical unspecified behaviourNoRequired
MISRA23_2.12.1 A project shall not contain unreachable codeYesRequired
MISRA23_2.22.2 A project shall not contain dead codeNoRequired
MISRA23_2.32.3 A project should not contain unused type declarationsYesAdvisory
MISRA23_2.42.4 A project should not contain unused tag declarationsYesAdvisory
MISRA23_2.52.5 A project should not contain unused macro declarationsYesAdvisory
MISRA23_2.62.6 A function should not contain unused label declarationsYesRequired
MISRA23_2.72.7 A function should not contain unused parametersYesAdvisory
MISRA23_3.13.1 The character sequences /* and // shall not be used within a commentYesRequired
MISRA23_3.23.2 Line-splicing shall not be used in // commentsYesRequired
MISRA23_4.14.1 Octal and Hexadecimal SequencesYesRequired
MISRA23_4.24.2 Trigraphs should not be usedYesAdvisory
MISRA23_5.0.15.0.1 Trigraph-like sequences should not be usedYesRequired
MISRA23_5.15.1 External identifiers shall be distinctYesRequired
MISRA23_5.25.2 Identifiers declared in the same scope and name space shall be distinctYesRequired
MISRA23_5.35.3 An identifier declared in an inner scope shall not hide an identifier declared in an outer scopeYesRequired
MISRA23_5.45.4 Macro identifiers shall be distinctYesRequired
MISRA23_5.55.5 Identifiers shall be distinct from macro namesYesRequired
MISRA23_5.65.6 A typedef name shall be a unique identifierYesRequired
MISRA23_5.75.7 A tag name shall be a unique identifierYesRequired
MISRA23_5.7.15.7.1 The character sequence /* shall not be used within a C-style commentYesRequired
MISRA23_5.7.25.7.2 Sections of code should not be "commented out"YesAdvisory
MISRA23_5.7.35.7.3 Line-splicing shall not be used in // commentsYesRequired
MISRA23_5.85.8 Identifiers that define objects or functions with external linkage shall be uniqueYesRequired
MISRA23_5.95.9 Identifiers that define objects or functions with internal linkage should be uniqueYesAdvisory
MISRA23_5.13.15.13.1 Within character literals and non raw-string literals, \ shall only be used to form a defined escape sequence or universal character nameYesRequired
MISRA23_5.13.25.13.2 Octal escape sequences, hexadecimal escape sequences and universal character names shall be terminatedYesRequired
MISRA23_5.13.35.13.3 Octal constants shall not be usedYesRequired
MISRA23_5.13.45.13.4 Unsigned integer literals shall be appropriately suffixedYesRequired
MISRA23_5.13.55.13.5 The lowercase form of L shall not be used as the first character in a literal suffixYesRequired
MISRA23_5.13.65.13.6 An integer-literal of type long long shall not use a single L or l in any suffixYesRequired
MISRA23_5.13.75.13.7 String literals with different encoding prefixes shall not be concatenatedYesRequired
MISRA23_6.0.16.0.1 Block scope declarations shall not be visually ambiguousYesRequired
MISRA23_6.0.26.0.2 When an array with external linkage is declared, its size should be explicitly specifiedYesAdvisory
MISRA23_6.0.46.0.4 The identifier main shall not be used for a function other than the global function mainYesRequired
MISRA23_6.16.1 Bit-fields shall only be declared with an appropriate typeYesRequired
MISRA23_6.26.2 Single-bit named bit fields shall not be of a signed typeYesRequired
MISRA23_6.2.46.2.4 A header file shall not contain definitions of functions or objects that are non-inline and have external linkageYesRequired
MISRA23_6.36.3 A bit field shall not be declared as a member of a unionYesRequired
MISRA23_6.4.26.4.2 Derived classes shall not conceal functions that are inherited from their basesYesRequired
MISRA23_6.5.16.5.1 A function or object with external linkage should be introduced in a header fileYesAdvisory
MISRA23_6.5.26.5.2 Internal linkage should be specified appropriatelyYesAdvisory
MISRA23_6.7.16.7.1 Local variables shall not have static storage durationYesRequired
MISRA23_6.7.26.7.2 Global variables shall not be usedYesRequired
MISRA23_6.8.26.8.2 A function must not return a reference or a pointer to a local variable with automatic storage durationYesMandatory
MISRA23_6.9.16.9.1 The same type aliases shall be used in all declarations of the same entityYesRequired
MISRA23_6.9.26.9.2 The names of the standard signed integer types and standard unsigned integer types should not be usedYesAdvisory
MISRA23_7.0.17.0.1 There shall be no conversion from type boolYesRequired
MISRA23_7.0.37.0.3 The numerical value of a character shall not be usedYesRequired
MISRA23_7.17.1 Octal constants shall not be usedYesRequired
MISRA23_7.27.2 A "u" or "U" suffix shall be applied to all integer constants that are represented in an unsigned typeYesRequired
MISRA23_7.37.3 The lowercase character "l" shall not be used in a literal suffixYesRequired
MISRA23_7.47.4 A string literal shall not be assigned to an object unless the object's type is "pointer to const-qualified char"NoRequired
MISRA23_7.11.17.11.1 nullptr shall be the only form of the null-pointer-constantYesRequired
MISRA23_7.11.27.11.2 Array to Pointer DecayYesRequired
MISRA23_8.18.1 Types shall be explicitly specifiedYesRequired
MISRA23_8.1.18.1.1 A non-transient lambda shall not implicitly capture thisYesRequired
MISRA23_8.1.28.1.2 Variables should be captured explicitly in a non-transient lambdaYesAdvisory
MISRA23_8.28.2 Use Named Parameters and Prototype FormYesRequired
MISRA23_8.2.38.2.3 A cast shall not remove any const or volatile qualification from the type accessed via a pointer or by referenceYesRequired
MISRA23_8.2.58.2.5 reinterpret_cast shall not be usedYesRequired
MISRA23_8.2.68.2.6 An object with integral, enumerated, or pointer to void type shall not be cast to a pointer typeYesRequired
MISRA23_8.2.78.2.7 Pointer to Integer CastYesAdvisory
MISRA23_8.2.88.2.8 An object pointer type shall not be cast to an integral type other than std::uintptr_t or std::intptr_tYesRequired
MISRA23_8.2.98.2.9 The operand to typeid shall not be an expression of polymorphic class typeYesRequired
MISRA23_8.2.108.2.10 Functions shall not call themselves, either directly or indirectlyYesRequired
MISRA23_8.38.3 All declarations of an object or function shall use the same names and type qualifiersYesRequired
MISRA23_8.3.18.3.1 The built-in unary - operator should not be applied to an expression of unsigned typeYesAdvisory
MISRA23_8.3.28.3.2 The built-in unary + operator should not be usedYesAdvisory
MISRA23_8.48.4 A compatible declaration shall be visible when an object or function with external linkage is definedYesRequired
MISRA23_8.58.5 An external object or function shall be declared once in one and only one fileYesRequired
MISRA23_8.68.6 An identifier with external linkage shall have exactly one external definitionYesRequired
MISRA23_8.78.7 Functions and objects should not be defined with external linkage if they are referenced in only one translation unitYesAdvisory
MISRA23_8.7.28.7.2 Subtraction between pointers shall only be applied to pointers that address elements of the same arrayYesRequired
MISRA23_8.88.8 The static storage class specifier shall be used in all declarations of objects and functions that have internal linkageYesRequired
MISRA23_8.98.9 An object should be declared at block scope if its identifier only appears in a single functionYesAdvisory
MISRA23_8.108.10 Non-static Inline FunctionsYesRequired
MISRA23_8.118.11 When an array with external linkage is declared, its size should be explicitly specifiedYesAdvisory
MISRA23_8.128.12 Within an enumerator list, the value of an implicitly-specified enumeration constant shall be uniqueYesRequired
MISRA23_8.138.13 A pointer should point to a const-qualified type whenever possibleNoAdvisory
MISRA23_8.148.14 The restrict type qualifier shall not be usedYesRequired
MISRA23_8.14.18.14.1 The right-hand operand of a logical && or || operator should not contain persistent side effectsYesAdvisory
MISRA23_8.158.15 All declarations of an object with an explicit alignment specification shall specify the same alignmentYesRequired
MISRA23_8.168.16 The alignment specification of zero should not appear in an object declarationYesAdvisory
MISRA23_8.178.17 At most one explicit alignment specifier should appear in an object declarationYesAdvisory
MISRA23_8.19.18.19.1 The comma operator shall not be used.YesAdvisory
MISRA23_9.19.1 The value of an object with automatic storage duration shall not be read before it has been setYesMandatory
MISRA23_9.29.2 The initializer for an aggregate or union shall be enclosed in bracesYesRequired
MISRA23_9.39.3 Arrays shall not be partially initializedYesRequired
MISRA23_9.3.19.3.1 The body of an iteration-statement or a selection-statement shall be acompound-statement
YesRequired
MISRA23_9.49.4 An element of an object shall not be initialized more than onceYesRequired
MISRA23_9.4.19.4.1 All if ... else if constructs shall be terminated with an else statementYesRequired
MISRA23_9.59.5 Where designated initializers are used to initialize an array object the size of the array shall be specified explicitlyYesRequired
MISRA23_9.5.29.5.2 A for-range-initializer shall contain at most one function callYesRequired
MISRA23_9.6.19.6.1 The goto statement should not be usedYesAdvisory
MISRA23_9.6.29.6.2 A goto statement shall reference a label in a surrounding blockYesRequired
MISRA23_9.6.39.6.3 The goto statement shall jump to a label declared later in the function bodyYesRequired
MISRA23_9.6.49.6.4 A function declared with the [[noreturn]] attribute shall not returnYesRequired
MISRA23_9.6.59.6.5 A function with non-void return type shall return a value on all pathsYesRequired
MISRA23_9.79.7 Atomic objects shall be appropriately initialized before being accessedYesMandatory
MISRA23_10.0.110.0.1 A declaration should not declare more than one variable or member variableYesAdvisory
MISRA23_10.110.1 Operands shall not be of an inappropriate essential typeYesRequired
MISRA23_10.1.110.1.1 The target type of a pointer or lvalue reference parameter should be const-qualified appropriatelyYesAdvisory
MISRA23_10.1.210.1.2 The volatile qualifier shall be used appropriatelyYesRequired
MISRA23_10.210.2 Expressions of essentially character type shall not be used inappropriately in addition and subtraction operationsNoRequired
MISRA23_10.2.110.2.1 An enumeration shall be defined with an explicit underlying typeYesRequired
MISRA23_10.2.210.2.2 Unscoped enumerations should not be declaredYesAdvisory
MISRA23_10.310.3 The value of an expression shall not be assigned to an object with a narrower essential type or of a different essential type categoryNoRequired
MISRA23_10.3.110.3.1 There should be no unnamed namespaces in header filesYesAdvisory
MISRA23_10.410.4 Both operands of an operator in which the usual arithmetic conversions are performed shall have the same essential type categoryYesRequired
MISRA23_10.4.110.4.1 The asm declaration shall not be usedYesRequired
MISRA23_10.510.5 The value of an expression should not be cast to an inappropriate essential typeYesAdvisory
MISRA23_10.610.6 The value of a composite expression shall not be assigned to an object with wider essential typeYesRequired
MISRA23_10.710.7 If a composite expression is used as one operand of an operator in which the usual arithmetic conversions are performed then the other operand shall not have wider essential typeNoRequired
MISRA23_10.810.8 The value of a composite expression shall not be cast to a different essential type category or a wider essential typeYesRequired
MISRA23_11.111.1 Conversions shall not be performed between a pointer to a function and any other typeYesRequired
MISRA23_11.211.2 Conversions shall not be performed between a pointer to an incomplete type
and any other type
YesRequired
MISRA23_11.311.3 A cast shall not be performed between a pointer to object type and a pointer to a different object typeYesRequired
MISRA23_11.3.111.3.1 Variables of array type should not be declaredYesAdvisory
MISRA23_11.3.211.3.2 The declaration of an object should contain no more than two levels of pointer indirectionYesAdvisory
MISRA23_11.411.4 A conversion should not be performed between a pointer to object and an integer typeYesRequired
MISRA23_11.511.5 A conversion should not be performed from pointer to void into pointer to objectYesAdvisory
MISRA23_11.611.6 A cast shall not be performed between pointer to void and an arithmetic typeYesRequired
MISRA23_11.6.111.6.1 All variables should be initializedYesAdvisory
MISRA23_11.6.311.6.3 Within an enumerator list, the value of an implicitly-specified
enumeration constant shall be unique
YesRequired
MISRA23_11.711.7 A cast shall not be performed between pointer to object and a non-integer arithmetic typeYesRequired
MISRA23_11.811.8 A conversion shall not remove any const, volatile or _Atomic qualification from the type pointed to by a pointerYesRequired
MISRA23_11.911.9 The macro NULL shall be the only permitted form of integer null pointer constantYesRequired
MISRA23_12.112.1 The precedence of operators within expressions should be made explicitNoAdvisory
MISRA23_12.212.2 The right hand operand of a shift operator shall lie in the range zero to one less than the width in bits of the essential type of the left hand operandYesRequired
MISRA23_12.2.112.2.1 Bit-fields should not be declaredYesAdvisory
MISRA23_12.2.212.2.2 A bit-field shall have an appropriate typeYesRequired
MISRA23_12.2.312.2.3 A named bit-field with signed integer type shall not have a length of one bitYesRequired
MISRA23_12.312.3 The comma operator shall not be used.YesAdvisory
MISRA23_12.3.112.3.1 The union keyword shall not be usedYesRequired
MISRA23_12.412.4 Evaluation of constant expressions should not lead to unsigned integer wrap-aroundNoAdvisory
MISRA23_13.113.1 Initializer lists shall not contain persistent side effectsYesRequired
MISRA23_13.1.113.1.1 Classes should not be inherited virtuallyYesAdvisory
MISRA23_13.1.213.1.2 An accessible base class shall not be both virtual and non-virtual in the same hierarchyYesRequired
MISRA23_13.213.2 The value of an expression and its persistent side effects shall be the same under all permitted evaluation ordersNoRequired
MISRA23_13.313.3 A full expression containing an increment (++) or decrement (--) operator should have no other potential side effects other than that caused by the increment or decrement operatorYesAdvisory
MISRA23_13.3.113.3.1 User-declared member functions shall use the virtual, override and final specifiers appropriatelyYesRequired
MISRA23_13.3.213.3.2 Parameters in an overriding virtual function shall not specify different default argumentsYesRequired
MISRA23_13.3.313.3.3 The parameters in all declarations or overrides of a function shall either be unnamed or have identical namesYesRequired
MISRA23_13.413.4 The result of an assignment operator should not be usedYesAdvisory
MISRA23_13.513.5 The right hand operand of a logical && or || operator shall not contain persistent side effectsYesRequired
MISRA23_13.613.6 The operand of the sizeof operator shall not contain any expression which has potential side effectsYesMandatory
MISRA23_14.114.1 A loop counter shall not have essentially floating typeYesRequired
MISRA23_14.1.114.1.1 Non-static data members should be either all private or all publicYesAdvisory
MISRA23_14.214.2 A for loop shall be well-formedNoRequired
MISRA23_14.314.3 Controlling expressions shall not be invariantNoRequired
MISRA23_14.414.4 The controlling expression of an if statement and the controlling expression of an iteration-statement shall have essentially Boolean typeYesRequired
MISRA23_15.0.215.0.2 User-provided copy and move member functions of a class should have appropriate signaturesYesAdvisory
MISRA23_15.115.1 The goto statement should not be usedYesAdvisory
MISRA23_15.1.115.1.1 An object's dynamic type shall not be used from within its constructor or destructorYesRequired
MISRA23_15.1.315.1.3 Conversion operators and constructors that are callable with a single argument shall be explicitYesRequired
MISRA23_15.1.515.1.5 A class shall only define an initializer-list constructor when it is the only constructorYesRequired
MISRA23_15.215.2 The goto statement shall jump to a label declared later in the same functionYesRequired
MISRA23_15.315.3 Any label referenced by a goto statement shall be declared in the same block, or in any block enclosing the goto statementYesRequired
MISRA23_15.415.4 There should be no more than one break or goto statement used to terminate any iteration statementYesAdvisory
MISRA23_15.515.5 A function should have a single point of exit at the endYesAdvisory
MISRA23_15.615.6 The body of an iteration-statement or a selection-statement shall be a compound-statement YesRequired
MISRA23_15.715.7 All if ... else if constructs shall be terminated with an else statementYesRequired
MISRA23_16.1Switch Statement not Well-formedYesRequired
MISRA23_16.216.2 A switch label shall only be used when the most closely-enclosing compound statement is the body of a switch statementYesRequired
MISRA23_16.316.3 An unconditional break statement shall terminate every switch-clauseYesRequired
MISRA23_16.416.4 Every switch statement shall have a default labelYesRequired
MISRA23_16.516.5 A default label shall appear as either the first or the last switch label of a switch statementYesRequired
MISRA23_16.5.116.5.1 The logical AND and logical OR operators shall not be overloadedYesRequired
MISRA23_16.5.216.5.2 The address-of operator shall not be overloadedYesRequired
MISRA23_16.616.6 Every switch statement shall have at least two switch-clausesYesRequired
MISRA23_16.6.116.6.1 Symmetrical operators should only be implemented as non-member functionsYesAdvisory
MISRA23_16.716.7 A switch-expression shall not have essentially Boolean typeNoRequired
MISRA23_17.117.1 The standard header file <stdarg.h> shall not be usedYesRequired
MISRA23_17.217.2 Functions shall not call themselves, either directly or indirectlyYesRequired
MISRA23_17.317.3 A function shall not be declared implicitlyYesMandatory
MISRA23_17.417.4 All exit paths from a function with non-void return type shall have an explicit return statement with an expressionYesRequired
MISRA23_17.517.5 The function argument corresponding to a parameter declared to have an array type shall have an appropriate number of elementsNoAdvisory
MISRA23_17.617.6 The declaration of an array parameter shall not contain the static keyword between the [ ]YesMandatory
MISRA23_17.7The value returned by a function having non-void return type shall be usedYesRequired
MISRA23_17.817.8 A function parameter should not be modifiedYesAdvisory
MISRA23_17.8.117.8.1 Function templates shall not be explicitly specializedYesRequired
MISRA23_17.1017.10 A function declared with a _Noreturn function specifier shall have void return typeYesRequired
MISRA23_17.1217.12 A function identifier should only be used with either a preceding &, or with a parenthesized parameter listYesRequired
MISRA23_17.1317.13 A function type shall not be type qualifiedYesRequired
MISRA23_18.118.1 A pointer resulting from arithmetic on a pointer operand shall address an element of the same array as that pointer operandNoRequired
MISRA23_18.1.118.1.1 An exception object shall not have pointer typeYesRequired
MISRA23_18.1.218.1.2 An empty throw shall only occur within the compound-statement of a catch handlerYesRequired
MISRA23_18.218.2 Subtraction between pointers shall only be applied to pointers that address elements of the same arrayYesRequired
MISRA23_18.318.3 The relational operators >, >=, < and <= shall not be applied to objects of pointer type except where they point into the same objectYesRequired
MISRA23_18.3.118.3.1 There should be at least one exception handler to catch all otherwise unhandled exceptionsYesAdvisory
MISRA23_18.3.218.3.2 An exception of class type shall be caught by const reference or referenceYesRequired
MISRA23_18.3.318.3.3 Handlers for a function-try-block of a constructor or destructor shall not refer to non-static members from their class or its basesYesRequired
MISRA23_18.418.4 The +, -, += and -= operators should not be applied to an expression of pointer typeNoAdvisory
MISRA23_18.518.5 Declarations should contain no more than two levels of pointer nestingNoAdvisory
MISRA23_18.5.218.5.2 Program-terminating functions should not be usedYesAdvisory
MISRA23_18.618.6 The address of an object with automatic or thread-local storage shall not be copied to another object that persists after the first object has ceased to existYesRequired
MISRA23_18.718.7 Flexible array members shall not be declaredYesRequired
MISRA23_18.818.8 Variable-length array types shall not be usedNoRequired
MISRA23_19.0.119.0.1 A line whose first token is # shall be a valid preprocessing directiveYesRequired
MISRA23_19.0.219.0.2 Function-like macros shall not be definedYesRequired
MISRA23_19.0.419.0.4 #undef should only be used for macros defined previously in the same fileYesAdvisory
MISRA23_19.119.1 An object shall not be assigned or copied to an overlapping objectNoMandatory
MISRA23_19.1.119.1.1 The defined preprocessor operator shall be used appropriatelyYesRequired
MISRA23_19.1.319.1.3 All identifiers used in the controlling expression of #if or #elif preprocessing directives shall be defined prior to evaluationNoRequired
MISRA23_19.219.2 The union keyword should not be usedYesAdvisory
MISRA23_19.2.119.2.1 Precautions shall be taken in order to prevent the contents of a header file being included more than onceYesRequired
MISRA23_19.2.319.2.3 The ' or " or \ characters and the /* or // character sequences shall not occur in a header file nameYesRequired
MISRA23_19.3.119.3.1 The # and ## operators should not be usedYesAdvisory
MISRA23_19.3.219.3.2 A macro parameter immediately following a # operator shall not immediately be followed by a ## operatorYesRequired
MISRA23_19.3.419.3.4 Parentheses shall be used to ensure macro arguments are expanded appropriatelyYesRequired
MISRA23_19.3.519.3.5 Tokens that look like a preprocessing directive shall not occur within a macro argumentYesAdvisory
MISRA23_19.6.119.6.1 The #pragma directive and the _Pragma operator should not be usedYesAdvisory
MISRA23_20.120.1 #include directives should only be preceded by preprocessor directives or commentsYesAdvisory
MISRA23_20.220.2 The ', " or backslash characters and the /* or // character sequences shall not occur in a header file nameYesRequired
MISRA23_20.320.3 The #include directive shall be followed by either a <filename> or "filename" sequenceYesRequired
MISRA23_20.420.4 A macro shall not be defined with the same name as a keywordYesRequired
MISRA23_20.520.5 #undef should not be usedYesAdvisory
MISRA23_20.620.6 Tokens that look like a preprocessing directive shall not occur within a macro argumentYesRequired
MISRA23_20.720.7 Expressions resulting from the expansion of macro parameters shall be enclosed in parenthesesNoRequired
MISRA23_20.820.8 The controlling expression of a #if or #elif preprocessing directive shall evaluate to 0 or 1NoRequired
MISRA23_20.920.9 All identifiers used in the controlling expression of #if or #elif preprocessing directives shall be #define'd before evaluationNoRequired
MISRA23_20.1020.10 The # and ## operators should not be usedYesAdvisory
MISRA23_20.1120.11 A macro parameter immediately following a # operator shall not immediately be followed by a ## operatorYesRequired
MISRA23_20.1220.12 A macro parameter used as an operand to the # or ## operators, which is itself subject to further macro replacement, shall only be used as an operand to these operatorsNoRequired
MISRA23_20.1320.13 A line whose first token is # shall be a valid preprocessing directiveYesRequired
MISRA23_20.1420.14 All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if, #ifdef or #ifndef directive to which they are relatedYesRequired
MISRA23_21.121.1 #define and #undef shall not be used on a reserved identifier or reserved macro nameYesRequired
MISRA23_21.221.2 Reserved Identifiers or MacrosYesRequired
MISRA23_21.2.121.2.1 The library functions atof, atoi, atol and atoll from library <cstdlib> shall not be usedYesRequired
MISRA23_21.2.221.2.2 The string handling functions from <cstring>, <cstdlib>, <cwchar> and <cinttypes> shall not be usedYesRequired
MISRA23_21.2.321.2.3 The library function system from <cstdlib> shall not be usedYesRequired
MISRA23_21.2.421.2.4 The macro offsetof shall not be usedYesRequired
MISRA23_21.321.3 The memory allocation and deallocation functions of &lt;stdlib.h&gt; shall not be usedYesRequired
MISRA23_21.421.4 The standard header file <setjmp.h> shall not be usedYesRequired
MISRA23_21.521.5 The standard header file <signal.h> shall not be usedYesRequired
MISRA23_21.621.6 The Standard Library input/output functions shall not be usedYesRequired
MISRA23_21.6.121.6.1 Dynamic memory should not be usedYesAdvisory
MISRA23_21.6.221.6.2 Dynamic memory shall be managed automaticallyYesRequired
MISRA23_21.6.421.6.4 If a project defines either a sized or unsized version of a global operator delete, then both shall be definedYesRequired
MISRA23_21.6.521.6.5 A pointer to an incomplete class type shall not be deletedYesRequired
MISRA23_21.721.7 The Standard Library functions atof, atoi, atol and atoll of <stdlib.h> shall not be usedYesRequired
MISRA23_21.821.8 The Standard Library termination functions of <stdlib.h> shall not be usedYesRequired
MISRA23_21.921.9 The library functions bsearch and qsort of <stdlib.h> shall not be usedYesRequired
MISRA23_21.1021.10 The Standard Library time and date functions shall not be usedYesRequired
MISRA23_21.10.121.10.1 The features of <cstdarg> shall not be usedYesRequired
MISRA23_21.10.221.10.2 The standard header file <csetjmp> shall not be usedYesRequired
MISRA23_21.1121.11 The standard header file <tgmath.h> shall not be usedYesAdvisory
MISRA23_21.1221.12 The standard header file <fenv.h> shall not be usedYesRequired
MISRA23_21.1721.17 Use of the string handling functions from <string.h> shall not result in accesses beyond the bounds of the objects referenced by their pointer parametersYesMandatory
MISRA23_21.1921.19 The pointers returned by the Standard Library functions localeconv, getenv, setlocale or, strerror shall only be used as if they have pointer to const-qualified typeYesMandatory
MISRA23_21.2021.20 The pointer returned by the C++ Standard Library functions asctime, ctime, gmtime, localtime, localeconv, getenv, setlocale or strerror must not be used following a subsequent call to the same functionYesMandatory
MISRA23_21.20.321.20.3 The facilities provided by the standard header file <csignal> shall not be usedYesRequired
MISRA23_21.2121.21 The Standard Library function system of <stdlib.h> shall not be usedYesRequired
MISRA23_21.2421.24 The random number generator functions of <stdlib.h> shall not be usedYesRequired
MISRA23_21.2621.26 The Standard Library function mtx_timedlock() shall only be invoked on mutex objects of appropriate mutex typeYesRequired
MISRA23_22.122.1 All resources obtained dynamically by means of Standard Library functions shall be explicitly releasedNoRequired
MISRA23_22.222.2 A block of memory shall only be freed if it was allocated by means of a Standard Library functionNoMandatory
MISRA23_22.322.3 The same file shall not be open for read and write access at the same time on different streamsNoRequired
MISRA23_22.3.122.3.1 The assert macro shall not be used with a constant-expressionYesRequired
MISRA23_22.422.4 There shall be no attempt to write to a stream which has been opened as read-onlyNoMandatory
MISRA23_22.4.122.4.1 The literal value zero shall be the only value assigned to errnoYesRequired
MISRA23_22.522.5 A pointer to a FILE object shall not be dereferencedNoMandatory
MISRA23_22.622.6 The value of a pointer to a FILE shall not be used after the associated stream has been closedNoMandatory
MISRA23_22.1122.11 A thread that was previously either joined or detached shall not be subsequently joined nor detachedYesRequired
MISRA23_22.1322.13 Thread objects, thread synchronization objects and thread-specific storage pointers shall have appropriate storage durationYesRequired
MISRA23_22.1722.17 No thread shall unlock a mutex or call cnd_wait() or cnd_timedwait() for a mutex it has not locked beforeYesRequired
MISRA23_24.5.124.5.1 The character handling functions from <cctype> and <cwctype> shall not be usedYesRequired
MISRA23_24.5.224.5.2 The C++ Standard Library functions memcpy, memmove and memcmp from <cstring> shall not be usedYesRequired
MISRA23_25.5.125.5.1 The setlocale and std::locale::global functions shall not be calledYesRequired
MISRA23_25.5.225.5.2 The pointers returned by the C++ Standard Library functions localeconv, getenv, setlocale or strerror must only be used as if they have pointer to const-qualified typeYesMandatory
MISRA23_25.5.325.5.3 The pointer returned by the C++ Standard Library functions asctime, ctime, gmtime, localtime, localeconv, getenv, setlocale or strerror must not be used following a subsequent call to the same functionYesMandatory
MISRA23_26.3.126.3.1 std::vector should not be specialized with boolYesAdvisory
MISRA23_28.6.128.6.1 The argument to std::move shall be a non-const lvalueYesRequired
MISRA23_30.0.130.0.1 The C Library input/output functions shall not be usedYesRequired
MISRA23_30.0.230.0.2 Reads and writes on the same file stream shall be separated by a positioning operationYesRequired
MISRA23_DIR_1.1Directive 1.1 Any implementation-defined behaviour on which the output of the program depends shall be documented and understoodNoRequired
MISRA23_DIR_2.1Directive 2.1 All source files shall compile without any compilation errorsYesRequired
MISRA23_DIR_3.1Directive 3.1 All code shall be traceable to documented requirementsNoRequired
MISRA23_DIR_4.1Directive 4.1 Run-time failures shall be minimizedNoRequired
MISRA23_DIR_4.2Directive 4.2 All usage of assembly language should be documentedNoAdvisory
MISRA23_DIR_4.3Directive 4.3 Assembly language shall be encapsulated and isolated.YesRequired
MISRA23_DIR_4.4Directive 4.4 Sections of code should not be "commented out"YesAdvisory
MISRA23_DIR_4.5Directive 4.5 Identifiers in the same name space with overlapping visibility should be typographically unambiguousYesAdvisory
MISRA23_DIR_4.6Directive 4.6 Typedefs that indicate size and signedness should be used in place of the basic numerical typesYesAdvisory
MISRA23_DIR_4.7Directive 4.7 If a function returns error information, then that error information shall be testedNoRequired
MISRA23_DIR_4.8Directive 4.8 If a pointer to a structure or union is never dereferenced within a translation unit, then the implementation of the object should be hiddenYesAdvisory
MISRA23_DIR_4.9Directive 4.9 A function should be used in preference to a function-like macro where they are interchangeableNoAdvisory
MISRA23_DIR_4.10Directive 4.10 Precautions shall be taken in order to prevent the contents of a header file being included more than onceYesRequired
MISRA23_DIR_4.11Directive 4.11 The validity of values passed to library functions shall be checkedNoRequired
MISRA23_DIR_4.12Directive 4.12 Dynamic memory allocation shall not be usedYesRequired
MISRA23_DIR_4.13Directive 4.13 Functions which are designed to provide operations on a resource should be called in an appropriate sequenceNoAdvisory
MISRA23_DIR_5.1Directive 5.1 There shall be no data races between threadsNoRequired
MISRA23_DIR_5.2Directive 5.2 There shall be no deadlocks between threadsNoRequired
MISRA23_DIR_5.3Directive 5.3 There shall be no dynamic thread creationYesRequired
MSC30-CDo not use the rand() function for generating pseudorandom numbersYesMedium
MSC32-CProperly seed pseudorandom number generatorsYesMedium
MSC33-CDo not pass invalid data to the asctime() functionYesHigh
MSC37-CEnsure that control never reaches the end of a non-void functionYesHigh
MSC38-CDo not treat a predefined identifier as an object if it might only be implemented as a macroYesLow
MSC39-CDo not call va_arg() on a va_list that has an indeterminate valueYesLow
MSC40-CDo not violate constraintsYesLow
MSC41-CNever hard code sensitive informationNoHigh
MSC50-CPPDo not use the rand() function for generating pseudorandom numbersYesMedium
MSC51-CPPEnsure your random number generator is properly seededYesMedium
MSC52-CPPValue-returning functions must return a value from all exit pathsYesMedium
MSC53-CPPDo not return from a function declared [[noreturn]]YesMedium
MSC54-CPPA signal handler must be a plain old functionYesHigh
OOP50-CPPDo not invoke virtual functions from constructors or destructorsYesLow
OOP51-CPPDo not slice derived objectsYesLow
OOP54-CPPGracefully handle self-copy assignmentYesLow
OOP55-CPPDo not use pointer-to-member operators to access nonexistent membersNoHigh
OOP56-CPPHonor replacement handler requirementsYes
OOP57-CPPPrefer special member functions and overloaded operators to C Standard Library functionsYesHigh
OOP58-CPPCopy operations must not mutate the source objectYesLow
POS30-CUse the readlink() function properlyYesHigh
POS34-CDo not call putenv() with a pointer to an automatic variable as the argumentYesHigh
POS35-CAvoid race conditions while checking for the existence of a symbolic linkYesHigh
POS36-CObserve correct revocation order while relinquishing privilegesYesHigh
POS37-CEnsure that privilege relinquishment is successfulYesHigh
POS38-CBeware of race conditions when using fork and file descriptorsYesMedium
POS39-CUse the correct byte ordering when transferring data between systemsYesMedium
POS44-CDo not use signals to terminate threadsYesLow
POS47-CDo not use threads that can be canceled asynchronouslyYesMedium
POS48-CDo not unlock or destroy another POSIX thread's mutexYesMedium
POS49-CWhen data must be accessed by multiple threads, provide a mutex and guarantee no adjacent data is also accessedNoMedium
POS50-CDeclare objects shared between POSIX threads with appropriate storage durationsYesMedium
POS51-CAvoid deadlock with POSIX threads by locking in predefined orderYesLow
POS52-CDo not perform operations that can block while holding a POSIX lockYesLow
POS53-CDo not use more than one mutex for concurrent waiting operations on a condition variableYesMedium
POS54-CDetect and handle POSIX library errorsYesHigh
POWER_OF_TEN_011 Simple Control FlowYes
POWER_OF_TEN_022 Loops with Fixed LimitsYes
POWER_OF_TEN_033 No Dynamic Memory AllocationYes
POWER_OF_TEN_044 Short FunctionsYes
POWER_OF_TEN_055 Use Assertion StatementsYes
POWER_OF_TEN_066 Declarations at Lowest ScopeYes
POWER_OF_TEN_07_A7A Check Parameters and Return Values - Ignored Return ValuesYes
POWER_OF_TEN_07_B7B Check Parameters and Return Values - Unchecked Parameters and Return ValuesYes
POWER_OF_TEN_088 Limit Preprocessor UsageYes
POWER_OF_TEN_09_A9A Restrict Pointer Usage - Multiple DereferencesYes
POWER_OF_TEN_09_B9B Restrict Pointer Usage - OtherYes
POWER_OF_TEN_1010 All Compiler WarningsYes
PRE30-CDo not create a universal character name through concatenationYesLow
PRE31-CAvoid side effects in arguments to unsafe macrosYesLow
PRE32-CDo not use preprocessor directives in invocations of function-like macrosYesLow
RECOMMENDED_00Commented Out CodeYes
RECOMMENDED_01Definitions in Header FilesYes
RECOMMENDED_02Files too longYes
RECOMMENDED_03Floating Equality TestYes
RECOMMENDED_04Functions Too LongYes
RECOMMENDED_05Functions shall not be declared implicitlyYes
RECOMMENDED_06Goto StatementsYes
RECOMMENDED_07Macros shall not be #define'd or #undef'd within a blockYes
RECOMMENDED_08Magic NumbersYes
RECOMMENDED_09Nested CommentsYes
RECOMMENDED_10Overly Complex FunctionsYes
RECOMMENDED_11Trigraphs shall not be usedYes
RECOMMENDED_12Unreachable CodeYes
RECOMMENDED_13Unused FunctionsYes
RECOMMENDED_14Unused C and C++ Local VariablesYes
RECOMMENDED_15Unused Static GlobalsYes
RECOMMENDED_16Variables should be commentedYes
RECOMMENDED_17Upper limit shall not be modified within the bounds of the loopYes
RECOMMENDED_19Comments Indicating Future FixesYes
RECOMMENDED_20Duplicate CodeYes
SIG30-CCall only asynchronous-safe functions within signal handlersYesHigh
SIG31-CDo not access shared objects in signal handlersYesHigh
SIG34-CDo not call signal() from within interruptible signal handlersYesLow
SIG35-CDo not return from a computational exception signal handlerNoLow
STI_UNUSEDUnused EntitiesYesRecommendedHigh
STR30-CDo not attempt to modify string literalsYesLow
STR31-CGuarantee that storage for strings has sufficient space for character data and the null terminatorYesHigh
STR32-CNull-terminated strings passed to library functionsYesHigh
STR34-CCast characters to unsigned char before converting to larger integer sizesNoMedium
STR37-CArguments to character-handling functions must be representable as an unsigned charYesLow
STR38-CDo not confuse narrow and wide character strings and functionsYesHigh
STR50-CPPGuarantee that storage for strings has sufficient space for character data and the null terminatorYesHigh
STR51-CPPDo not attempt to create a std::string from a null pointerYesHigh
STR52-CPPUse valid references, pointers, and iterators to reference elements of a basic_stringYesHigh
STR53-CPPRange check element accessYesHigh
WIN30-CProperly pair allocation and deallocation functionsYesLow