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