CodeAnt AI home pagelight logodark logo
  • Dashboard
  • Dashboard
  • Documentation
  • Demo Call with CEO
  • Blog
  • Slack
  • Get Started
    • CodeAnt AI
    • Setup
    • Control Center
    • Pull Request Review
    • IDE
    • Compliance
      • GDPR
      • HIPAA
      • ISO/IEC 27001:2022
      • ISO 27002:2022
      • RBI Baseline Cyber Security and Resilience Requirements
      • PCI DSS v4.0
      • SOC 2
      • MISRA-C-2012
      • MISRA-CPP-2023
      • AUTOSAR-CPP-2014
    • Anti-Patterns
    • Code Governance
    • Infrastructure Security Database
    • Application Security Database
    Compliance

    MISRA-CPP-2023

    misra-cpp2023-5.7.2

    Sections of code should not be “commented out”.

    misra-cpp2023-0.0.1

    A function shall not contain unreachable statements.

    misra-cpp2023-0.0.2

    Controlling expressions should not be invariant.

    misra-cpp2023-0.1.1

    A value should not be unnecessarily written to a local object.

    misra-cpp2023-0.1.2

    The value returned by a function shall be used.

    misra-cpp2023-0.2.1

    Variables with limited visibility should be used at least once.

    misra-cpp2023-0.2.2

    A named function parameter shall be used at least once.

    misra-cpp2023-0.2.3

    Types with limited visibility should be used at least once.

    misra-cpp2023-0.2.4

    Functions with limited visibility should be used at least once.

    misra-cpp2023-4.1.1

    A program shall conform to ISO/IEC 14882:2017 (C++17).

    misra-cpp2023-4.1.2

    Deprecated features should not be used.

    misra-cpp2023-4.1.3

    Deprecated features should not be used.

    misra-cpp2023-4.6.1

    Operations on a memory location shall be sequenced appropriately.

    misra-cpp2023-5.0.1

    Trigraph-like sequences should not be used.

    misra-cpp2023-5.7.1

    The character sequence /* shall not be used within a C-style comment.

    misra-cpp2023-5.7.3

    Line-splicing shall not be used in // comments.

    misra-cpp2023-5.10.1

    User-defined identifiers shall have an appropriate form.

    misra-cpp2023-5.13.1

    Within character literals and non raw-string literals,\ shall only be used form a defined escape sequence or universal character name.

    misra-cpp2023-5.13.2

    Octal escape sequences, hexadecimal escape sequences and universal character names shall be terminated.

    misra-cpp2023-5.13.3

    Octal constants shall not be used.

    misra-cpp2023-5.13.4

    Unsigned integer literals shall be appropriately suffixed.

    misra-cpp2023-5.13.5

    The lowercase form of L shall not be used as the first character in a literal suffix.

    misra-cpp2023-5.13.6

    An integer-literal of type long long shall not use a single L or l in any suffix.

    misra-cpp2023-5.13.7

    String literals with different encoding prefixes shall not be concatenated.

    misra-cpp2023-6.0.1

    Block scope declarations shall not be visually ambiguous.

    misra-cpp2023-6.0.2

    When an array with external linkage is declared, its size should be explicitly specified.

    misra-cpp2023-6.0.3

    The only declarations in the global namespace should be main, namespace declarations and extern “C” declarations.

    misra-cpp2023-6.0.4

    The identifier main shall not be used for a function other than the global function main.

    misra-cpp2023-6.2.1

    The one-definition rule shall not be violated.

    misra-cpp2023-6.2.2

    All declarations of a variable or function shall have the same type.

    misra-cpp2023-6.2.3

    The source code used to implement an entity shall appear only once.

    misra-cpp2023-6.2.4

    A header file shall not contain definitions of functions or objects that are non-inline and have external linkage.

    misra-cpp2023-6.4.1

    A variable declared in an inner scope shall not hide a variable declared in an outer scope.

    misra-cpp2023-6.4.2

    Derived classes shall not conceal functions that are inherited from their bases.

    misra-cpp2023-6.4.3

    A name that is present in a dependent base shall not be resolved by unqualified lookup.

    misra-cpp2023-6.5.1

    A function or object with external linkage should be introduced in a header file.

    misra-cpp2023-6.5.2

    Internal linkage should be specified appropriately.

    misra-cpp2023-6.7.1

    Local variables shall not have static storage duration.

    misra-cpp2023-6.7.2

    Global variables shall not be used.

    misra-cpp2023-6.8.1

    An object shall not be accessed outside of its lifetime.

    misra-cpp2023-6.8.2

    A function must not return a reference or a pointer to a local variable with automatic storage duration.

    misra-cpp2023-6.8.3

    An assignment operator shall not assign the address of an object with automatic storage duration to an object with a greater lifetime.

    misra-cpp2023-6.8.4

    Member functions returning references to their object should be ref-qualified appropriately.

    misra-cpp2023-6.9.1

    The same type aliases shall be used in all declarations of the same entity.

    misra-cpp2023-6.9.2

    The names of the standard signed integer types and standard unsigned integer types should not be used.

    misra-cpp2023-7.0.1

    There shall be no conversion from type bool.

    misra-cpp2023-7.0.2

    There shall be no conversion to type bool.

    misra-cpp2023-7.0.3

    The numerical value of a character shall not be used.

    misra-cpp2023-7.0.4

    The operands of bitwise operators and shift operators shall be appropriate.

    misra-cpp2023-7.0.5

    Integral promotion and the usual arithmetic conversions shall not change the signedness or the type category of an operand.

    misra-cpp2023-7.0.6

    Assignment between numeric types shall be appropriate.

    misra-cpp2023-7.11.1

    nullptr shall be the only form of the null-pointer-constant.

    misra-cpp2023-7.11.2

    An array passed as a function argument shall not decay to a pointer.

    misra-cpp2023-7.11.3

    A conversion from function type to pointer-to-function type shall only occur in appropriate contexts.

    misra-cpp2023-8.0.1

    Parentheses should be used to make the meaning of an expression appropriately explicit.

    misra-cpp2023-8.1.1

    A non-transient lambda shall not implicitly capture this.

    misra-cpp2023-8.1.2

    Variables should be captured explicitly in a non-transient lambda.

    misra-cpp2023-8.2.1

    A virtual base class shall only be cast to a derived class by means of dynamic_cast.

    misra-cpp2023-8.2.2

    C-style casts and functional notation casts shall not be used.

    misra-cpp2023-8.2.3

    A cast shall not remove any const or volatile qualification from the type accessed via a pointer or by reference.

    misra-cpp2023-8.2.4

    Casts shall not be performed between a pointer to a function and any other type.

    misra-cpp2023-8.2.5

    reinterpret_cast shall not be used.

    misra-cpp2023-8.2.6

    An object with integral, enumerated, or pointer to void type shall not be cast to a pointer type.

    misra-cpp2023-8.2.7

    A cast should not convert a pointer type to an integral type.

    misra-cpp2023-8.2.8

    An object pointer type shall not be cast to an integral type other than std::uintptr_t or std::intptr_t.

    misra-cpp2023-8.2.9

    The operand to typeid shall not be an expression of polymorphic class type.

    misra-cpp2023-8.2.10

    Functions shall not call themselves, either directly or indirectly.

    misra-cpp2023-8.2.11

    An argument passed via ellipsis shall have an appropriate type.

    misra-cpp2023-8.3.1

    The built-in unary - operator should not be applied to an expression of unsigned type.

    misra-cpp2023-8.3.2

    The built-in unary + operator should not be used.

    misra-cpp2023-8.7.1

    Pointer arithmetic shall not form an invalid pointer.

    misra-cpp2023-8.7.2

    Subtraction between pointers shall only be applied to pointers that address elements of the same array.

    misra-cpp2023-8.9.1

    The built-in realational operators shall not be applied to objects of pointer type, except where they point to elements of the same array.

    misra-cpp2023-8.14.1

    The right hand operand of a logical && or || operator should not contain persistent side effects.

    misra-cpp2023-8.18.1

    An object or subobject must not be copied to an overlapping object.

    misra-cpp2023-8.18.2

    The result of an assignment operator should not be used.

    misra-cpp2023-8.19.1

    The comma operator should not be used.

    misra-cpp2023-8.20.1

    An unsigned arithmetic operation with constant operands should not wrap.

    misra-cpp2023-9.2.1

    An explicit type conversion shall not be an expression statement.

    misra-cpp2023-9.3.1

    The body of an iteration-statement or a selection-statement shall be a compound-statement.

    misra-cpp2023-9.4.1

    All if … else if constructs shall be terminated with an else statement.

    misra-cpp2023-9.4.2

    The structure of a switch statement shall be appropriate.

    misra-cpp2023-9.5.1

    Legacy for statements should be simple.

    misra-cpp2023-9.5.2

    A for-range-initializer shall contain at most one function call.

    misra-cpp2023-9.6.1

    The goto statement should not be used.

    misra-cpp2023-9.6.2

    A goto statement shall reference a label in a surrounding block.

    misra-cpp2023-9.6.3

    The goto statement shall jump to a label declared later in the function body.

    misra-cpp2023-9.6.4

    A function declared with the [[noreturn]] attribute shall not return.

    misra-cpp2023-9.6.5

    A function with non-void return type shall return a value on all paths.

    misra-cpp2023-10.0.1

    A declaration should not declare more than one variable or member variable.

    misra-cpp2023-10.1.1

    The target type of a pointer or lvalue reference parameter should be const-qualified appropriately.

    misra-cpp2023-10.1.2

    The volatile qualifier shall be used appropriately.

    misra-cpp2023-10.2.1

    An enumeration shall be defined with an explicit underlying type.

    misra-cpp2023-10.2.2

    Unscoped enumerations should not be declared.

    misra-cpp2023-10.2.3

    The numerical value of unscoped enumeration with no fixed underlying type shall not be used.

    misra-cpp2023-10.3.1

    There should be no unnamed namespaces in header files.

    misra-cpp2023-10.4.1

    The asm declaration shall not be used.

    misra-cpp2023-11.3.1

    Variables of array type should not be declared.

    misra-cpp2023-11.3.2

    The declaration of an object should contain no more than two levels of pointer indirection.

    misra-cpp2023-11.6.1

    All variables should be initialized.

    misra-cpp2023-11.6.2

    The value of an object must not be read before it has been set.

    misra-cpp2023-11.6.3

    Within an enumerator list, the value of an implicitly-specified enumeration constant shall be unique.

    misra-cpp2023-12.2.1

    Bit-fields should not be declared.

    misra-cpp2023-12.2.2

    A bit-field shall have an appropriate type.

    misra-cpp2023-12.2.3

    A named bit-field with signed integer type shall not have a length of one bit.

    misra-cpp2023-12.3.1

    The union keyword shall not be used.

    misra-cpp2023-13.1.1

    Classes should not be inherited virtually.

    misra-cpp2023-13.1.2

    An accessible base class shall not be both virtual and non-virtual in the same hierarchy.

    misra-cpp2023-13.3.1

    User-declared member functions shall use the virtual, override, and final specifiers appropriately.

    misra-cpp2023-13.3.2

    Parameters in an overriding virtual function shall not specify different default arguments.

    misra-cpp2023-13.3.3

    The parameters in all declarations or overrides of a function shall either be unnamed or have identical names.

    misra-cpp2023-13.3.4

    A comparison of a potentially virtual pointer to member function shall only be with nullptr.

    misra-cpp2023-14.1.1

    Non-static data members should be either all private or all public.

    misra-cpp2023-15.0.1

    Special member functions shall be provided appropriately.

    misra-cpp2023-15.0.2

    User-provided copy and move member functions of a class should have appropriate signatures.

    misra-cpp2023-15.1.1

    An object’s dynamic type shall not be used from within its constructor or destructor.

    misra-cpp2023-15.1.2

    All constructor of a class should explicitly initialize all of its virtual base classes and immediate base classes.

    misra-cpp2023-15.1.3

    Conversion operators and constructors that are callable with a single argument shall be explicit.

    misra-cpp2023-15.1.4

    All direct, non-static data members of a class should be initialized before the class object is accessible.

    misra-cpp2023-15.1.5

    A class shall only define an initializer-list constructor when it is the only constructor.

    misra-cpp2023-16.5.1

    The logical AND and logical OR operators shall not be overloaded.

    misra-cpp2023-16.5.2

    The address-of operator shall not be overloaded.

    misra-cpp2023-16.6.1

    Symmetrical operators should only be implemented as non-member functions.

    misra-cpp2023-17.8.1

    Function templates shall not be explicitly specialized.

    misra-cpp2023-18.1.1

    An exception object shall not have pointer type.

    misra-cpp2023-18.1.2

    An empty throw shall only occur within the compound-statement of a catch handler.

    misra-cpp2023-18.3.1

    There should be at least one exception handler to catch all otherwise unhandled exceptions.

    misra-cpp2023-18.3.2

    An exception of class type shall be caught by const reference or reference.

    misra-cpp2023-18.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 bases.

    misra-cpp2023-18.4.1

    Exception-unfriendly functions shall be noexcept.

    misra-cpp2023-18.5.1

    A noexcept function should not attempt to propagate an exception to the calling function.

    misra-cpp2023-18.5.2

    Program-terminating functions should not be used.

    misra-cpp2023-19.0.1

    A line whose first token is # shall be a valid preprocessing directive.

    misra-cpp2023-19.0.2

    Function-like macros shall not be defined.

    misra-cpp2023-19.0.3

    #include directives should only be preceded by preprocessor directives or comments.

    misra-cpp2023-19.0.4

    #undef should only be used for macros defined previously in the same file.

    misra-cpp2023-19.1.1

    The defined preprocessor operator shall be used appropriately.

    misra-cpp2023-19.1.2

    The defined preprocessor operator shall be used appropriately.

    misra-cpp2023-19.1.3

    All identifiers used in the controlling expression of #if or #elif preprocessing directives shall be defined prior to evaluation.

    misra-cpp2023-19.2.1

    Precautions shall be taken in order to prevent the contents of a header file being included more than once.

    misra-cpp2023-19.2.2

    The #include directive shall be followed by either a or “filename” sequence.

    misra-cpp2023-19.2.3

    The ’ or ” or \ characters and the /* or // character sequences shall not occur in a header file name.

    misra-cpp2023-19.3.1

    The # and ## preprocessor operators should not be used.

    misra-cpp2023-19.3.2

    A macro parameter immediately following a # operator shall not be immediately followed by a ## operator.

    misra-cpp2023-19.3.3

    The argument to a mixed-use macro parameter shall not be subject to further expansion.

    misra-cpp2023-19.3.4

    Parentheses shall be used to ensure macro arguments are expanded appropriately.

    misra-cpp2023-19.3.5

    Tokens that look like a preprocessing directive shall not occur within a macro argument.

    misra-cpp2023-19.6.1

    The #pragma directive and the _Pragma operator should not be used.

    misra-cpp2023-21.2.1

    The library functions atof, atoi, atol and atoll from shall not be used.

    misra-cpp2023-21.2.2

    The string handling functions from , , and shall not be used.

    misra-cpp2023-21.2.3

    The library function system from shall not be used.

    misra-cpp2023-21.2.4

    The macro offsetof shall not be used.

    misra-cpp2023-21.6.1

    Dynamic memory should not be used.

    misra-cpp2023-21.6.2

    Dynamic memory shall be managed automatically.

    misra-cpp2023-21.6.3

    Advanced memory management shall not be used.

    misra-cpp2023-21.6.4

    If a project defines either a sized or unsized version of a global operator delete, then both shall be defined.

    misra-cpp2023-21.6.5

    A pointer to an incomplete class type shall not be deleted.

    misra-cpp2023-21.10.1

    The features of shall not be used.

    misra-cpp2023-21.10.2

    The standard header file shall not be used.

    misra-cpp2023-21.10.3

    The facilities provided by the standard header file shall not be used.

    misra-cpp2023-22.3.1

    The assert macro shall not be used with a constant-expression.

    misra-cpp2023-22.4.1

    The literal value zero shall be the only value assigned to errno.

    misra-cpp2023-23.11.1

    The raw pointer constructors of std::shared_ptr and std::unique_ptr should not be used.

    misra-cpp2023-24.5.1

    The character handling function from and shall not be used.

    misra-cpp2023-24.5.2

    The C++ standard library function memcpy, memmove and memcpy from shall not be used.

    misra-cpp2023-25.5.1

    The setlocale and std::locale::global functions shall not be called.

    misra-cpp2023-25.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 type.

    misra-cpp2023-25.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 function.

    misra-cpp2023-26.3.1

    std::vector should not be specialized with bool.

    misra-cpp2023-28.3.1

    Predicates shall not have persistent side effects.

    misra-cpp2023-28.6.1

    The argument to std::move shall be a non-const lvalue.

    misra-cpp2023-28.6.2

    Forwarding references and std::forward shall be used together.

    misra-cpp2023-28.6.3

    An object shall not be used while in a potentially moved-from state.

    misra-cpp2023-28.6.4

    The result of std::remove, std::remove_if, std::unique and empty shall be used.

    misra-cpp2023-30.0.1

    The C Library input/output functions shall not be used.

    misra-cpp2023-30.0.2

    Reads and writes on the same file stream shall be separated by positioning operation.

    MISRA-C-2012AUTOSAR-CPP-2014
    twitterlinkedin
    Powered by Mintlify
    Assistant
    Responses are generated using AI and may contain mistakes.