このページの内容は最新ではありません。最新版の英語を参照するには、ここをクリックします。

MISRA C++:2023 ルールおよび命令

MISRA C++:2023 ルールおよび命令のリストと説明

Polyspace® Bug Finder™ では、コードをチェックして MISRA™ C++:2023 規格に対する違反を検出できます。MISRA C++:2023 規格は ISO/IEC 14882:2017 (一般的には C++17 と呼ばれる) を対象としています。この新しい規格はMISRA C++:2008 ルールの更新版であり、AUTOSAR C++14 ルールが取り込まれています。

この新しい規格の違反をチェックするには、MISRA C++:2023 のチェック (-misra-cpp-2023) 解析オプションを使用します。MISRA C++:2023 ルールへの違反が検出されると、Polyspace Bug Finder によって違反が報告され、違反の原因となったイベントが指摘されます。

Polyspace Bug Finder は MISRA C++:2023 規格のすべてのルールをサポートします。Polyspace の MISRA C++:2023 への対応範囲の詳細は、Polyspace でのコーディング規約のサポートを参照してください。

Polyspace 結果

すべて展開する

MISRA C++:2023 Rule 0.0.1A function shall not contain unreachable statements (R2024b 以降)
MISRA C++:2023 Rule 0.0.2Controlling expressions should not be invariant (R2024b 以降)
MISRA C++:2023 Rule 0.1.1A value should not be unnecessarily written to a local object (R2024b 以降)
MISRA C++:2023 Rule 0.1.2The value returned by a function shall be used (R2024b 以降)
MISRA C++:2023 Rule 0.2.1Variables with limited visibility should be used at least once (R2024b 以降)
MISRA C++:2023 Rule 0.2.2A named function parameter shall be used at least once (R2024b 以降)
MISRA C++:2023 Rule 0.2.3Types with limited visibility should be used at least once (R2024b 以降)
MISRA C++:2023 Rule 0.2.4Functions with limited visibility should be used at least once (R2024b 以降)
MISRA C++:2023 Dir 0.3.1Floating-point arithmetic should be used appropriately (R2024b 以降)
MISRA C++:2023 Dir 0.3.2A function call shall not violate the function's preconditions (R2024b 以降)
MISRA C++:2023 Rule 4.1.1A program shall conform to ISO/IEC 14882:2017 (C++17) (R2024b 以降)
MISRA C++:2023 Rule 4.1.2Deprecated features should not be used (R2024b 以降)
MISRA C++:2023 Rule 4.1.3There shall be no occurrence of undefined or critical unspecified behaviour (R2024b 以降)
MISRA C++:2023 Rule 4.6.1Operations on a memory location shall be sequenced appropriately (R2024b 以降)
MISRA C++:2023 Rule 5.0.1Trigraph-like sequences should not be used (R2024b 以降)
MISRA C++:2023 Rule 5.7.1The character sequence /* shall not be used within a C-style comment (R2024b 以降)
MISRA C++:2023 Dir 5.7.2Sections of code should not be "commented out" (R2024b 以降)
MISRA C++:2023 Rule 5.7.3Line-splicing shall not be used in // comments. (R2024b 以降)
MISRA C++:2023 Rule 5.10.1User-defined identifiers shall have an appropriate form (R2024b 以降)
MISRA C++:2023 Rule 5.13.1Within character literals and non raw-string literals, \ shall only be used to form a defined escape sequence or universal character name (R2024b 以降)
MISRA C++:2023 Rule 5.13.2Octal escape sequences, hexadecimal escape sequences and universal character names shall be terminated (R2024b 以降)
MISRA C++:2023 Rule 5.13.3Octal constants shall not be used (R2024b 以降)
MISRA C++:2023 Rule 5.13.4Unsigned integer literals shall be appropriately suffixed (R2024b 以降)
MISRA C++:2023 Rule 5.13.5The lowercase form of L shall not be used as the first character in a literal suffix (R2024b 以降)
MISRA C++:2023 Rule 5.13.6An integer-literal of type long long shall not use a single L or l in any suffix (R2024b 以降)
MISRA C++:2023 Rule 5.13.7String literals with different encoding prefixes shall not be concatenated (R2024b 以降)
MISRA C++:2023 Rule 6.0.1Block scope declarations shall not be visually ambiguous (R2024b 以降)
MISRA C++:2023 Rule 6.0.2When an array with external linkage is declared, its size should be explicitly specified (R2024b 以降)
MISRA C++:2023 Rule 6.0.3The only declarations in the global namespace should be main, namespace declarations and extern "C" declarations (R2024b 以降)
MISRA C++:2023 Rule 6.0.4The identifier main shall not be used for a function other than the global function main (R2024b 以降)
MISRA C++:2023 Rule 6.2.1The one-definition rule shall not be violated (R2024b 以降)
MISRA C++:2023 Rule 6.2.2All declarations of a variable or function shall have the same type (R2024b 以降)
MISRA C++:2023 Rule 6.2.3The source code used to implement an entity shall appear only once (R2024b 以降)
MISRA C++:2023 Rule 6.2.4A header file shall not contain definitions of functions or objects that are non-inline and have external linkage (R2024b 以降)
MISRA C++:2023 Rule 6.4.1A variable declared in an inner scope shall not hide a variable declared in an outer scope (R2024b 以降)
MISRA C++:2023 Rule 6.4.2Derived classes shall not conceal functions that are inherited from their bases (R2024b 以降)
MISRA C++:2023 Rule 6.4.3A name that is present in a dependent base shall not be resolved by unqualified lookup (R2024b 以降)
MISRA C++:2023 Rule 6.5.1A function or object with external linkage should be introduced in a header file (R2024b 以降)
MISRA C++:2023 Rule 6.5.2Internal linkage should be specified appropriately (R2024b 以降)
MISRA C++:2023 Rule 6.7.1Local variables shall not have static storage duration (R2024b 以降)
MISRA C++:2023 Rule 6.7.2Global variables shall not be used (R2024b 以降)
MISRA C++:2023 Rule 6.8.1An object shall not be accessed outside of its lifetime (R2024b 以降)
MISRA C++:2023 Rule 6.8.2A function must not return a reference or a pointer to a local variable with automatic storage duration (R2024b 以降)
MISRA C++:2023 Rule 6.8.3An assignment operator shall not assign the address of an object with automatic storage duration to an object with a greater lifetime (R2024b 以降)
MISRA C++:2023 Rule 6.8.4Member functions returning references to their object should be ref-qualified appropriately (R2024b 以降)
MISRA C++:2023 Rule 6.9.1The same type aliases shall be used in all declarations of the same entity (R2024b 以降)
MISRA C++:2023 Rule 6.9.2The names of the standard signed integer types and standard unsigned integer types should not be used (R2024b 以降)
MISRA C++:2023 Rule 7.0.1There shall be no conversion from type bool (R2024b 以降)
MISRA C++:2023 Rule 7.0.2There shall be no conversion to type bool (R2024b 以降)
MISRA C++:2023 Rule 7.0.3The numerical value of a character shall not be used (R2024b 以降)
MISRA C++:2023 Rule 7.0.4The operands of bitwise operators and shift operators shall be appropriate (R2024b 以降)
MISRA C++:2023 Rule 7.0.5Integral promotion and the usual arithmetic conversions shall not change the signedness or the type category of an operand (R2024b 以降)
MISRA C++:2023 Rule 7.0.6Assignment between numeric types shall be appropriate (R2024b 以降)
MISRA C++:2023 Rule 7.11.1nullptr shall be the only form of the null-pointer-constant (R2024b 以降)
MISRA C++:2023 Rule 7.11.2An array passed as a function argument shall not decay to a pointer (R2024b 以降)
MISRA C++:2023 Rule 7.11.3A conversion from function type to pointer-to-function type shall only occur in appropriate contexts (R2024b 以降)
MISRA C++:2023 Rule 8.0.1Parentheses should be used to make the meaning of an expression appropriately explicit (R2024b 以降)
MISRA C++:2023 Rule 8.1.1A non-transient lambda shall not implicitly capture this (R2024b 以降)
MISRA C++:2023 Rule 8.1.2Variables should be captured explicitly in a non-transient lambda (R2024b 以降)
MISRA C++:2023 Rule 8.2.1A virtual base class shall only be cast to a derived class by means of dynamic_cast (R2024b 以降)
MISRA C++:2023 Rule 8.2.2C-style casts and functional notation casts shall not be used (R2024b 以降)
MISRA C++:2023 Rule 8.2.3A cast shall not remove any const or volatile qualification from the type accessed via a pointer or by reference (R2024b 以降)
MISRA C++:2023 Rule 8.2.4Casts shall not be performed between a pointer to function and any other type (R2024b 以降)
MISRA C++:2023 Rule 8.2.5reinterpret_cast shall not be used (R2024b 以降)
MISRA C++:2023 Rule 8.2.6An object with integral, enumerated, or pointer to void type shall not be cast to a pointer type (R2024b 以降)
MISRA C++:2023 Rule 8.2.7A cast should not convert a pointer type to an integral type. (R2024b 以降)
MISRA C++:2023 Rule 8.2.8An object pointer type shall not be cast to an integral type other than std::uintptr_t or std::intptr_t (R2024b 以降)
MISRA C++:2023 Rule 8.2.9The operand to typeid shall not be an expression of polymorphic class type (R2024b 以降)
MISRA C++:2023 Rule 8.2.10Functions shall not call themselves, either directly or indirectly (R2024b 以降)
MISRA C++:2023 Rule 8.2.11An argument passed via ellipsis shall have an appropriate type (R2024b 以降)
MISRA C++:2023 Rule 8.3.1The built-in unary - operator should not be applied to an expression of unsigned type (R2024b 以降)
MISRA C++:2023 Rule 8.3.2The built-in unary + operator should not be used (R2024b 以降)
MISRA C++:2023 Rule 8.7.1Pointer arithmetic shall not form an invalid pointer (R2024b 以降)
MISRA C++:2023 Rule 8.7.2Subtraction between pointers shall only be applied to pointers that address elements of the same array (R2024b 以降)
MISRA C++:2023 Rule 8.9.1The built-in relational operators >, >=, < and <= shall not be applied to objects of pointer type, except where they point to elements of the same array (R2024b 以降)
MISRA C++:2023 Rule 8.14.1The right-hand operand of a logical && or || operator should not contain persistent side effects (R2024b 以降)
MISRA C++:2023 Rule 8.18.1An object or subobject must not be copied to an overlapping object (R2024b 以降)
MISRA C++:2023 Rule 8.18.2The result of an assignment operator should not be used (R2024b 以降)
MISRA C++:2023 Rule 8.19.1The comma operator should not be used (R2024b 以降)
MISRA C++:2023 Rule 8.20.1An unsigned arithmetic operation with constant operands should not wrap (R2024b 以降)
MISRA C++:2023 Rule 9.2.1An explicit type conversion shall not be an expression statement (R2024b 以降)
MISRA C++:2023 Rule 9.3.1The body of an iteration-statement or a selection-statement shall be a compound-statement (R2024b 以降)
MISRA C++:2023 Rule 9.4.1All if ... else if constructs shall be terminated with an else statement (R2024b 以降)
MISRA C++:2023 Rule 9.4.2The structure of a switch statement shall be appropriate (R2024b 以降)
MISRA C++:2023 Rule 9.5.1Legacy for statements should be simple (R2024b 以降)
MISRA C++:2023 Rule 9.5.2A for-range-initializer shall contain at most one function call (R2024b 以降)
MISRA C++:2023 Rule 9.6.1The goto statement should not be used (R2024b 以降)
MISRA C++:2023 Rule 9.6.2A goto statement shall reference a label in a surrounding block (R2024b 以降)
MISRA C++:2023 Rule 9.6.3 The goto statement shall jump to a label declared later in the function body (R2024b 以降)
MISRA C++:2023 Rule 9.6.4A function declared with the [[noreturn]] attribute shall not return (R2024b 以降)
MISRA C++:2023 Rule 9.6.5A function with non-void return type shall return a value on all paths (R2024b 以降)
MISRA C++:2023 Rule 10.0.1A declaration should not declare more than one variable or member variable (R2024b 以降)
MISRA C++:2023 Rule 10.1.1The target type of a pointer or lvalue reference parameter should be const-qualified appropriately (R2024b 以降)
MISRA C++:2023 Rule 10.1.2The volatile qualifier shall be used appropriately (R2024b 以降)
MISRA C++:2023 Rule 10.2.1An enumeration shall be defined with an explicit underlying type (R2024b 以降)
MISRA C++:2023 Rule 10.2.2Unscoped enumerations should not be declared (R2024b 以降)
MISRA C++:2023 Rule 10.2.3The numeric value of an unscoped enumeration with no fixed underlying type shall not be used (R2024b 以降)
MISRA C++:2023 Rule 10.3.1There should be no unnamed namespaces in header files (R2024b 以降)
MISRA C++:2023 Rule 10.4.1The asm declaration shall not be used (R2024b 以降)
MISRA C++:2023 Rule 11.3.1Variables of array type should not be declared (R2024b 以降)
MISRA C++:2023 Rule 11.3.2The declaration of an object should contain no more than two levels of pointer indirection (R2024b 以降)
MISRA C++:2023 Rule 11.6.1All variables should be initialized (R2024b 以降)
MISRA C++:2023 Rule 11.6.2The value of an object must not be read before it has been set (R2024b 以降)
MISRA C++:2023 Rule 11.6.3Within an enumerator list, the value of an implicitly-specified enumeration constant shall be unique (R2024b 以降)
MISRA C++:2023 Rule 12.2.1Bit-fields should not be declared (R2024b 以降)
MISRA C++:2023 Rule 12.2.2A bit-field shall have an appropriate type (R2024b 以降)
MISRA C++:2023 Rule 12.2.3A named bit-field with signed integer type shall not have a length of one bit (R2024b 以降)
MISRA C++:2023 Rule 12.3.1The union keyword shall not be used (R2024b 以降)
MISRA C++:2023 Rule 12.3.1The union keyword shall not be used (R2024b 以降)
MISRA C++:2023 Rule 13.1.1Classes should not be inherited virtually (R2024b 以降)
MISRA C++:2023 Rule 13.1.2An accessible base class shall not be both virtual and non-virtual in the same hierarchy (R2024b 以降)
MISRA C++:2023 Rule 13.3.1User-declared member functions shall use the virtual, override and final specifiers appropriately (R2024b 以降)
MISRA C++:2023 Rule 13.3.2Parameters in an overriding virtual function shall not specify different default arguments (R2024b 以降)
MISRA C++:2023 Rule 13.3.3The parameters in all declarations or overrides of a function shall either be unnamed or have identical names (R2024b 以降)
MISRA C++:2023 Rule 13.3.4A comparison of a potentially virtual pointer to member function shall only be with nullptr (R2024b 以降)
MISRA C++:2023 Rule 14.1.1Non-static data members should be either all private or all public (R2024b 以降)
MISRA C++:2023 Rule 15.0.1Special member functions shall be provided appropriately (R2024b 以降)
MISRA C++:2023 Rule 15.0.2User-provided copy and move member functions of a class should have appropriate signatures (R2024b 以降)
MISRA C++:2023 Rule 15.1.1An object's dynamic type shall not be used from within its constructor or destructor (R2024b 以降)
MISRA C++:2023 Rule 15.1.2All constructors of a class should explicitly initialize all of its virtual base classes and immediate base classes (R2024b 以降)
MISRA C++:2023 Rule 15.1.3Conversion operators and constructors that are callable with a single argument shall be explicit (R2024b 以降)
MISRA C++:2023 Rule 15.1.4All direct, non-static data members of a class should be initialized before the class object is accessible (R2024b 以降)
MISRA C++:2023 Rule 15.1.5A class shall only define an initializer-list constructor when it is the only constructor (R2024b 以降)
MISRA C++:2023 Dir 15.8.1User-provided copy assignment operators and move assignment operators shall handle self-assignment (R2024b 以降)
MISRA C++:2023 Rule 16.5.1The logical AND and logical OR operators shall not be overloaded (R2024b 以降)
MISRA C++:2023 Rule 16.5.2The address-of operator shall not be overloaded (R2024b 以降)
MISRA C++:2023 Rule 16.6.1Symmetrical operators should only be implemented as non-member functions (R2024b 以降)
MISRA C++:2023 Rule 17.8.1Function templates shall not be explicitly specialized (R2024b 以降)
MISRA C++:2023 Rule 18.1.1An exception object shall not have pointer type (R2024b 以降)
MISRA C++:2023 Rule 18.1.2An empty throw shall only occur within the compound-statement of a catch handler (R2024b 以降)
MISRA C++:2023 Rule 18.3.1There should be at least one exception handler to catch all otherwise unhandled exceptions (R2024b 以降)
MISRA C++:2023 Rule 18.3.2An exception of class type shall be caught by const reference or reference (R2024b 以降)
MISRA C++:2023 Rule 18.3.3Handlers for a function-try-block of a constructor or destructor shall not refer to non-static members from their class or its bases (R2024b 以降)
MISRA C++:2023 Rule 18.4.1Exception-unfriendly functions shall be noexcept (R2024b 以降)
MISRA C++:2023 Rule 18.5.1A noexcept function should not attempt to propagate an exception to the calling function (R2024b 以降)
MISRA C++:2023 Rule 18.5.2Program-terminating functions should not be used (R2024b 以降)
MISRA C++:2023 Rule 19.0.1A line whose first token is # shall be a valid preprocessing directive (R2024b 以降)
MISRA C++:2023 Rule 19.0.2Function-like macros shall not be defined (R2024b 以降)
MISRA C++:2023 Rule 19.0.3#include directives should only be preceded by preprocessor directives or comments (R2024b 以降)
MISRA C++:2023 Rule 19.0.4#undef should only be used for macros defined previously in the same file (R2024b 以降)
MISRA C++:2023 Rule 19.1.1The defined preprocessor operator shall be used appropriately (R2024b 以降)
MISRA C++:2023 Rule 19.1.2All #else, #elif and #endif preprocessor directives shall reside in the same file as the #if, #ifdef or #ifndef directive to which they are related (R2024b 以降)
MISRA C++:2023 Rule 19.1.3All identifiers used in the controlling expression of #if or #elif preprocessing directives shall be defined prior to evaluation (R2024b 以降)
MISRA C++:2023 Rule 19.2.1Precautions shall be taken in order to prevent the contents of a header file being included more than once (R2024b 以降)
MISRA C++:2023 Rule 19.2.2The #include directive shall be followed by either a <filename> or "filename" sequence (R2024b 以降)
MISRA C++:2023 Rule 19.2.3The ' or " or \ characters and the /* or // character sequences shall not occur in a header file name (R2024b 以降)
MISRA C++:2023 Rule 19.3.1The # and ## preprocessor operators should not be used (R2024b 以降)
MISRA C++:2023 Rule 19.3.2A macro parameter immediately following a # operator shall not be immediately followed by a ## operator (R2024b 以降)
MISRA C++:2023 Rule 19.3.3The argument to a mixed-use macro parameter shall not be subject to further expansion (R2024b 以降)
MISRA C++:2023 Rule 19.3.4Parentheses shall be used to ensure macro arguments are expanded appropriately (R2024b 以降)
MISRA C++:2023 Rule 19.3.5Tokens that look like a preprocessing directive shall not occur within a macro argument (R2024b 以降)
MISRA C++:2023 Rule 19.6.1The #pragma directive and the _Pragma operator should not be used (R2024b 以降)
MISRA C++:2023 Rule 21.2.1The library functions atof, atoi, atol and atoll from <cstdlib> shall not be used (R2024b 以降)
MISRA C++:2023 Rule 21.2.2The string handling functions from <cstring>, <cstdlib>, <cwchar> and <cinttypes> shall not be used (R2024b 以降)
MISRA C++:2023 Rule 21.2.3The library function system from <cstdlib> shall not be used (R2024b 以降)
MISRA C++:2023 Rule 21.2.4The macro offsetof shall not be used (R2024b 以降)
MISRA C++:2023 Rule 21.6.1Dynamic memory should not be used (R2024b 以降)
MISRA C++:2023 Rule 21.6.2Dynamic memory shall be managed automatically (R2024b 以降)
MISRA C++:2023 Rule 21.6.3Advanced memory management shall not be used (R2024b 以降)
MISRA C++:2023 Rule 21.6.4If a project defines either a sized or unsized version of a global operator delete, then both shall be defined (R2024b 以降)
MISRA C++:2023 Rule 21.6.5A pointer to an incomplete class type shall not be deleted (R2024b 以降)
MISRA C++:2023 Rule 21.10.1The features of <cstdarg> shall not be used (R2024b 以降)
MISRA C++:2023 Rule 21.10.2The standard header file <csetjmp> shall not be used (R2024b 以降)
MISRA C++:2023 Rule 21.10.3The facilities provided by the standard header file <csignal> shall not be used (R2024b 以降)
MISRA C++:2023 Rule 22.3.1The assert macro shall not be used with a constant-expression (R2024b 以降)
MISRA C++:2023 Rule 22.4.1The literal value zero shall be the only value assigned to errno (R2024b 以降)
MISRA C++:2023 Rule 23.11.1The raw pointer constructors of std::shared_ptr and std::unique_ptr should not be used (R2024b 以降)
MISRA C++:2023 Rule 24.5.1The character handling functions from <cctype> and <cwctype> shall not be used (R2024b 以降)
MISRA C++:2023 Rule 24.5.2The C++ Standard Library functions memcpy, memmove, memcmp from <cstring> shall not be used (R2024b 以降)
MISRA C++:2023 Rule 25.5.1The setlocale and std::locale::global functions shall not be called (R2024b 以降)
MISRA C++:2023 Rule 25.5.2The 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 (R2024b 以降)
MISRA C++:2023 Rule 25.5.3The 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 (R2024b 以降)
MISRA C++:2023 Rule 26.3.1std::vector should not be specialized with bool (R2024b 以降)
MISRA C++:2023 Rule 28.3.1Predicates shall not have persistent side effects (R2024b 以降)
MISRA C++:2023 Rule 28.6.1The argument to std::move shall be a non-const lvalue (R2024b 以降)
MISRA C++:2023 Rule 28.6.2Forwarding references and std::forward shall be used together (R2024b 以降)
MISRA C++:2023 Rule 28.6.3An object shall not be used while in a potentially moved-from state (R2024b 以降)
MISRA C++:2023 Rule 28.6.4The result of std::remove, std::remove_if, std::unique and empty shall be used (R2024b 以降)
MISRA C++:2023 Rule 30.0.1The C Library input/output functions shall not be used (R2024b 以降)
MISRA C++:2023 Rule 30.0.2Reads and writes on the same file stream shall be separated by a positioning operation (R2024b 以降)

トピック