SonarSource Rules
  • Products

    In-IDE

    Code Quality and Security in your IDE with SonarQube Ide

    IDE extension that lets you fix coding issues before they exist!

    Discover SonarQube for IDE

    SaaS

    Code Quality and Security in the cloud with SonarQube Cloud

    Setup is effortless and analysis is automatic for most languages

    Discover SonarQube Cloud

    Self-Hosted

    Code Quality and Security Self-Hosted with SonarQube Server

    Fast, accurate analysis; enterprise scalability

    Discover SonarQube Server
  • SecretsSecrets
  • ABAPABAP
  • AnsibleAnsible
  • ApexApex
  • AzureResourceManagerAzureResourceManager
  • CC
  • C#C#
  • C++C++
  • CloudFormationCloudFormation
  • COBOLCOBOL
  • CSSCSS
  • DartDart
  • DockerDocker
  • FlexFlex
  • GitHub ActionsGitHub Actions
  • GoGo
  • HTMLHTML
  • JavaJava
  • JavaScriptJavaScript
  • JSONJSON
  • JCLJCL
  • KotlinKotlin
  • KubernetesKubernetes
  • Objective CObjective C
  • PHPPHP
  • PL/IPL/I
  • PL/SQLPL/SQL
  • PythonPython
  • RPGRPG
  • RubyRuby
  • RustRust
  • ScalaScala
  • ShellShell
  • SwiftSwift
  • TerraformTerraform
  • TextText
  • TypeScriptTypeScript
  • T-SQLT-SQL
  • VB.NETVB.NET
  • VB6VB6
  • XMLXML
  • YAMLYAML
C++

C++ static code analysis

Unique rules to find Bugs, Vulnerabilities, Security Hotspots, and Code Smells in your C++ code

  • All rules 674
  • Vulnerability13
  • Bug139
  • Security Hotspot19
  • Code Smell503

  • Quick Fix 91
Filtered: 17 rules found
misra-advisory
    Impact
      Clean code attribute
        1. The "goto" statement should not be used

           Code Smell
        2. "std::vector" should not be specialized with "bool"

           Code Smell
        3. Variables of array type should not be declared

           Code Smell
        4. "Unscoped enumerations" should not be declared

           Code Smell
        5. Functions with "limited visibility" should be "used" at least once

           Code Smell
        6. All variables should be initialized

           Code Smell
        7. Variables should be captured explicitly in a non-"transient lambda"

           Code Smell
        8. The "#" and "##" preprocessor operators should not be used

           Code Smell
        9. A "noexcept" function should not attempt to propagate an exception to the calling function

           Bug
        10. Classes should not be inherited virtually

           Code Smell
        11. A "declaration" should not declare more than one variable or member variable

           Code Smell
        12. There should be no unnamed namespaces in "header files"

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

           Code Smell
        14. The "declaration" of an object should contain no more than two levels of pointer indirection

           Code Smell
        15. The names of the "standard signed integer types" and "standard unsigned integer types" should not be used

           Code Smell
        16. "#include" directives should only be preceded by preprocessor directives or comments

           Code Smell
        17. Variables with "limited visibility" should be "used" at least once

           Code Smell

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

        intentionality - clear
        maintainability
        Code Smell
        • pitfall
        • misra-c++2023
        • misra-advisory

        Why is this an issue?

        More Info

        This rule is part of MISRA C++:2023.

        MISRA Rule 11.3.2

        Category: Advisory

        Analysis Type: Decidable,Single Translation Unit

        Amplification

        Any typedef-name appearing in a declaration [1] is treated as if it were replaced by the type that it denotes.

        Note: the pointer decay that occurs when declaring a function parameter of array type introduces a level of pointer indirection.

        Rationale

        Use of more than two levels of indirection can seriously impair the ability to understand the behaviour of the code, and therefore should be avoided.

        Example

        typedef int8_t * INTPTR1;
        using INTPTR2 = int8_t *;
        
        
        struct s
        {
          int8_t *   s1;                                // Compliant
          int8_t **  s2;                                // Compliant
          int8_t *** s3;                                // Non-compliant
        };
        
        struct s *   ps1;                               // Compliant
        struct s **  ps2;                               // Compliant
        struct s *** ps3;                               // Non-compliant
        
        int8_t **  (   *pfunc1 )();                     // Compliant
        int8_t **  (  **pfunc2 )();                     // Compliant
        int8_t **  ( ***pfunc3 )();                     // Non-compliant
        int8_t *** (  **pfunc4 )();                     // Non-compliant
        
        void function( int8_t  *   par1,                // Compliant
                       int8_t  **  par2,                // Compliant
                       int8_t  *** par3,                // Non-compliant
                       INTPTR1 *   par4,                // Compliant
                       INTPTR1 *   const * const par5,  // Non-compliant
                       int8_t  *   par6[],              // Compliant
                       int8_t  **  par7[],              // Non-compliant
                       int8_t  ** &par8)                // Compliant
        
        {
           int8_t  *   ptr1;                            // Compliant
           int8_t  **  ptr2;                            // Compliant
           int8_t  *** ptr3;                            // Non-compliant
           INTPTR2 *   ptr4;                            // Compliant
           INTPTR2 *   const * const ptr5;              // Non-compliant
           int8_t  *   ptr6[ 10 ];                      // Compliant
           int8_t  **  ptr7[ 10 ];                      // Compliant
        }
        

        Explanation of types:

        • par1 and ptr1 are of type pointer to int8_t.
        • par2 and ptr2 are of type pointer to pointer to int8_t.
        • par3 and ptr3 are of type pointer to a pointer to a pointer to int8_t. This is three levels and is non-compliant.
        • par4 and ptr4 are expanded to a type of pointer to a pointer to int8_t.
        • par5 and ptr5 are expanded to a type of const pointer to a const pointer to a pointer to int8_t. This is three levels and is non-compliant.
        • par6 is of type pointer to pointer to int8_t because arrays are converted to a pointer to the initial element of the array.
        • ptr6 is of type array of pointers to int8_t.
        • par7 is of type pointer to pointer to pointer to int8_t because arrays are converted to a pointer to the initial element of the array. This is three levels and is non-compliant.
        • ptr7 is of type array of pointer to pointer to int8_t. This is compliant.
        • par8 is of type reference to pointer to pointer to int8_t. This is compliant.

        Glossary

        [1] Declaration

        A declaration introduces the name of an entity into a translation unit (see [basic.def]/1).

        An entity may be declared several times. The first declaration of an entity in a translation unit is called an introduction [2]. All subsequent declarations are called redeclarations [3].

        A definition [4] is a declaration, as described in [basic.def]/2.

        [2] Introduction

        See declaration [1].

        [3] Redeclaration

        See declaration [1].

        [4] Definition

        See declaration [1].

        Copyright The MISRA Consortium Limited © 2023

          Available In:
        • SonarQube IdeCatch issues on the fly,
          in your IDE
        • SonarQube CloudDetect issues in your GitHub, Azure DevOps Services, Bitbucket Cloud, GitLab repositories
        • SonarQube ServerAnalyze code in your
          on-premise CI

        © 2008-2025 SonarSource SA. All rights reserved.

        Privacy Policy | Cookie Policy | Terms of Use