Products
In-IDE
IDE extension that lets you fix coding issues before they exist!
Discover SonarQube for IDE
SaaS
Setup is effortless and analysis is automatic for most languages
Discover SonarQube Cloud
Self-Hosted
Fast, accurate analysis; enterprise scalability
Discover SonarQube Server

Secrets
ABAP
Ansible
Apex
AzureResourceManager
C
C#
C++
CloudFormation
COBOL
CSS
Dart
Docker
Flex
GitHub Actions
Go
HTML
Java
JavaScript
JSON
JCL
Kotlin
Kubernetes
Objective C
PHP
PL/I
PL/SQL
Python
RPG
Ruby
Rust
Scala
Shell
Swift
Terraform
Text
TypeScript
T-SQL
VB.NET
VB6
XML
YAML

C++ static code analysis

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

Filtered: 50 rules found

misra-advisory

Impact

Clean code attribute

Floating-point arithmetic should be used appropriately
Bug
The "goto" statement should not be used
Code Smell
"Legacy for statements" should be "simple"
Code Smell
The built-in unary "+" operator should not be used
Code Smell
"User-provided" copy and move member functions of a class should have appropriate signatures
Code Smell
"Symmetrical operators" should only be implemented as non-member functions
Code Smell
Member functions returning references to their object should be "ref-qualified" appropriately
Code Smell
"std::vector" should not be specialized with "bool"
Code Smell
Variables of array type should not be declared
Code Smell
"Unscoped enumerations" should not be declared
Code Smell
Functions with "limited visibility" should be "used" at least once
Code Smell
All variables should be initialized
Code Smell
The raw pointer constructors of "std::shared_ptr" and "std::unique_ptr" should not be used
Code Smell
All direct, non-static data members of a class should be initialized before the class object is "accessible"
Code Smell
Variables should be captured explicitly in a non-"transient lambda"
Code Smell
Deprecated features should not be used
Code Smell
"Dynamic memory" should not be used
Code Smell
The "#pragma" directive and the "_Pragma" operator should not be used
Code Smell
The "#" and "##" preprocessor operators should not be used
Code Smell
Program-terminating functions should not be used
Code Smell
A "noexcept" function should not attempt to propagate an exception to the calling function
Bug
There should be at least one exception handler to catch all otherwise unhandled exceptions
Bug
All constructors of a class should explicitly initialize all of its virtual base classes and immediate base classes
Code Smell
Non-static data members should be either all "private" or all "public"
Code Smell
Classes should not be inherited virtually
Code Smell
Bit-fields should not be declared
Code Smell
A "declaration" should not declare more than one variable or member variable
Code Smell
There should be no unnamed namespaces in "header files"
Code Smell
The only "declarations" in the global namespace should be "main", namespace declarations and "extern "C"" declarations
Code Smell
The target type of a pointer or "lvalue" reference parameter should be const-qualified appropriately
Code Smell
The result of an assignment operator should not be "used"
Code Smell
An unsigned arithmetic operation with constant operands should not wrap
Bug
The comma operator should not be used
Code Smell
The right-hand operand of a logical "&&" or "||" operator should not contain "persistent side effects"
Bug
The built-in unary "-" operator should not be applied to an expression of unsigned type
Bug
A cast should not convert a pointer type to an integral type
Code Smell
The "declaration" of an object should contain no more than two levels of pointer indirection
Code Smell
Parentheses should be used to make the meaning of an expression appropriately explicit
Code Smell
The names of the "standard signed integer types" and "standard unsigned integer types" should not be used
Code Smell
Internal linkage should be specified appropriately
Code Smell
A function or object with external linkage should be "introduced" in a "header file"
Code Smell
When an array with external linkage is declared, its size should be explicitly specified
Code Smell
"#undef" should only be used for macros defined previously in the same file
Code Smell
"#include" directives should only be preceded by preprocessor directives or comments
Code Smell
Sections of code should not be "commented out"
Code Smell
"Trigraph-like sequences" should not be used
Code Smell
A value should not be "unnecessarily written" to a local object
Code Smell
Types with "limited visibility" should be "used" at least once
Code Smell
Variables with "limited visibility" should be "used" at least once
Code Smell
Controlling expressions should not be invariant
Bug

The "#pragma" directive and the "_Pragma" operator should not be used

intentionality - complete

maintainability

Code Smell

lock-in
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 19.6.1 - The `#pragma` directive and the `_Pragma` operator should not be used

[cpp.pragma] Implementation 1
[cpp.pragma.op] 1

Category: Advisory

Analysis: Decidable, Single Translation Unit

Rationale

The effects of the #pragma directive and the _Pragma operator are implementation-defined.

Example

#pragma once                    // Non-compliant

#define P( x ) _Pragma( #x )    // Non-compliant

_Pragma( "once" )               // Non-compliant

Available In:

Catch issues on the fly,
in your IDE

Detect issues in your GitHub, Azure DevOps Services, Bitbucket Cloud, GitLab repositories

Analyze code in your
on-premise CI

In-IDE

SaaS

Self-Hosted