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: 50 rules found
misra-advisory
    Impact
      Clean code attribute
        1. Floating-point arithmetic should be used appropriately

           Bug
        2. The "goto" statement should not be used

           Code Smell
        3. "Legacy for statements" should be "simple"

           Code Smell
        4. The built-in unary "+" operator should not be used

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

           Code Smell
        6. "Symmetrical operators" should only be implemented as non-member functions

           Code Smell
        7. Member functions returning references to their object should be "ref-qualified" appropriately

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

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

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

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

           Code Smell
        12. All variables should be initialized

           Code Smell
        13. The raw pointer constructors of "std::shared_ptr" and "std::unique_ptr" should not be used

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

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

           Code Smell
        16. Deprecated features should not be used

           Code Smell
        17. "Dynamic memory" should not be used

           Code Smell
        18. The "#pragma" directive and the "_Pragma" operator should not be used

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

           Code Smell
        20. Program-terminating functions should not be used

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

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

           Bug
        23. All constructors of a class should explicitly initialize all of its virtual base classes and immediate base classes

           Code Smell
        24. Non-static data members should be either all "private" or all "public"

           Code Smell
        25. Classes should not be inherited virtually

           Code Smell
        26. Bit-fields should not be declared

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

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

           Code Smell
        29. The only "declarations" in the global namespace should be "main", namespace declarations and "extern "C"" declarations

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

           Code Smell
        31. The result of an assignment operator should not be "used"

           Code Smell
        32. An unsigned arithmetic operation with constant operands should not wrap

           Bug
        33. The comma operator should not be used

           Code Smell
        34. The right-hand operand of a logical "&&" or "||" operator should not contain "persistent side effects"

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

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

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

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

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

           Code Smell
        40. Internal linkage should be specified appropriately

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

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

           Code Smell
        43. "#undef" should only be used for macros defined previously in the same file

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

           Code Smell
        45. Sections of code should not be "commented out"

           Code Smell
        46. "Trigraph-like sequences" should not be used

           Code Smell
        47. A value should not be "unnecessarily written" to a local object

           Code Smell
        48. Types with "limited visibility" should be "used" at least once

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

           Code Smell
        50. Controlling expressions should not be invariant

           Bug

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

        intentionality - clear
        maintainability
        Code Smell
        • confusing
        • 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 8.3.2 - The built-in unary + operator should not be used

        [expr.unary.op] / 7

        Category: Advisory

        Analysis: Decidable,Single Translation Unit

        Rationale

        The built-in unary + operator triggers integral promotion, but otherwise performs no other operation. When its operand is a function name or lambda, decay to a function pointer is triggered. The use of static_cast is recommended instead as it makes it clear that these conversions are present.

        Example

        auto  x = + u8a;             // Non-compliant - triggers promotion to int
        auto pf = +[](){};           // Non-compliant - pf is a void(*)()
        
        x = +1;                      // Non-compliant
        x =+ 1;                      // Non-compliant - unary +, not +=
        
        enum A : uint8_t { one };
        enum B : uint8_t { two };
        
        uint8_t operator+( B b ) { return b; }
        
        auto a = +one;               // Non-compliant
        auto b = +two;               // Rule does not apply
        auto c = operator+( two );   // Rule does not apply
        

        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