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 798
  • Vulnerability14
  • Bug173
  • Security Hotspot19
  • Code Smell592

  • Quick Fix 99
Filtered: 41 rules found
unpredictable
    Impact
      Clean code attribute
        1. Globals should not depend on possibly not yet initialized variables

           Code Smell
        2. Coroutine should have co_return on each execution path or provide return_void

           Bug
        3. Thread local variables should not be used in coroutines

           Code Smell
        4. Arguments evaluation order should not be relied on

           Bug
        5. A single statement should not have more than one resource allocation

           Code Smell
        6. Functions that throw exceptions should not be used as hash functions

           Code Smell
        7. A call to "wait()" on a "std::condition_variable" should have a condition

           Bug
        8. Keywords shall not be used as macros identifiers

           Code Smell
        9. Incomplete types should not be deleted

           Code Smell
        10. Dereferenced null pointers should not be bound to references

           Code Smell
        11. Header guards should be followed by a matching "#define" macro

           Code Smell
        12. "memcmp" should only be called with pointers to trivially copyable types with no padding

           Bug
        13. Stack allocated memory and non-owned memory should not be freed

           Bug
        14. Destructors should not be called explicitly

           Code Smell
        15. Floating-point arithmetic should be used appropriately

           Bug
        16. There shall be no occurrence of "undefined" or "critical unspecified behaviour"

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

           Code Smell
        18. 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

           Bug
        19. An object shall not be accessed outside of its lifetime

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

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

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

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

           Bug
        24. Local variables shall not have static storage duration

           Code Smell
        25. 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

           Bug
        26. The library functions "atof", "atoi", "atol" and "atoll" from "<cstdlib>" shall not be used

           Bug
        27. The "defined" preprocessor operator shall be used appropriately

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

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

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

           Bug
        31. 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

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

           Bug
        33. Pointer arithmetic shall not form an invalid pointer

           Bug
        34. Operations on a memory location shall be sequenced appropriately

           Bug
        35. The numeric value of an "unscoped enumeration" with no fixed "underlying type" shall not be used

           Code Smell
        36. A function or object with external linkage should be "introduced" in a "header file"

           Code Smell
        37. The source code used to implement an "entity" shall appear only once

           Bug
        38. The "one-definition rule" shall not be violated

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

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

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

           Bug

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

        intentionality - complete
        reliability
        maintainability
        Bug
        • unpredictable
        • misra-c++2023
        • misra-advisory

        Why is this an issue?

        More Info

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

        Usage of this content is governed by Sonar’s terms and conditions. Redistribution is prohibited.

        Rule 18.3.1 - There should be at least one exception handler to catch all otherwise unhandled exceptions

        [except.terminate] Implementation 1.2, 1.10

        Category: Advisory

        Analysis: Decidable,Single Translation Unit

        Amplification

        The function main should include a try-catch with a catch ( ... ) handler.

        The catch handlers of this try-block, and any code within main that is outside of this try-block, should not attempt to propagate an exception. To make this rule decidable, any call to a function having a potentially-throwing exception specification ([except.spec]/3) is assumed to propagate an exception.

        For the purposes of this rule, where a development environment allows a function other than main to be nominated as the entry point of the program, that function shall be treated as if it were main.

        Rationale

        If a program throws an exception that is not caught, the program terminates in an implementation-defined manner. In particular, it is implementation-defined whether the call stack is unwound before termination, meaning that some destructors may not be executed. By enforcing the provision of a "last-ditch catch-all", the developer can ensure that the program terminates in a consistent manner.

        Example

        int main()                           // Compliant
        {
          try
          {
            // Program code
          }
        
          catch ( specific_type & e )        // Optional, explicit handler(s) are permitted
          {
            // Handle expected exceptions
          }
        
          catch ( ... )                      // Catch-all handler should be provided
          {
            // Handle unexpected exceptions
          }
        
          return 0;
        }
        
        void logError( char const * message );
        
        int main()                           // Compliant
        try
        {
          // Program code
        }
        
        catch ( ... )                        // Catch-all handler
        {
          try
          {
            logError( "Unexpected" );
          }
        
          catch (...)
          {
            // Logging also threw
          }
        }
        
        int main()                           // Non-compliant - handler may throw
        try
        {
          // Program code
        }
        
        catch ( ... )                        // Catch-all handler
        {
          logError( "Unexpected");           // Potentially throwing function may lead to
        }                                    // an exception propagating from main
        

        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

        © 2025 SonarSource Sàrl. All rights reserved.

        Privacy Policy | Cookie Policy | Terms of Use