C and C++ Warning Class Index

• #
• <
• /
• A
• B
• C
• D
• E
• F
• G
• H
• I
• K
• L
• M
• N
• O
• P
• Q
• R
• S
• T
• U
• V
• W
• X
• Z

#

• ## Follows # Operator

<

• <cctype>

  • Use of <cctype> Function

• <cwctype>

  • Use of <cwctype> Function

• <fenv.h>

  • Use of <fenv.h> Exception Handling Function

• <setjmp.h>

  • Use of <setjmp.h>

• <signal.h>

  • Use of <signal.h>

• <stdarg.h>

  • Use of <stdarg.h> Feature

• <stdint.h>

  • Use of <stdint.h> Small Integer Constant Macro

• <stdio.h>

  • Use of <stdio.h> Input/Output
  • Use of <stdio.h> Input/Output Macro

• <stdlib.h>

  • Use of <stdlib.h> Allocator/Deallocator
  • Use of <stdlib.h> Allocator/Deallocator Macro

• <tgmath.h>

  • Inappropriate Argument to <tgmath.h> Macro
  • Inconsistent Types of Arguments to <tgmath.h> Macro
  • Use of <tgmath.h>

• <time.h>

  • Use of <time.h> Time/Date Function

• <wchar.h>

  • Use of <wchar.h> Input/Output
  • Use of <wchar.h> Input/Output Macro

/

• /* in // Comment
• // in Comment

A

• AddAccessAllowedAce, Use of
• AddAccessDeniedAce, Use of
• Addition Overflow of Size
• Addition Overflow of Allocation Size
• AfxLoadLibrary, Use of
• AfxParseURL, Use of

• alignment

  • Explicit Zero Alignment
  • Inconsistent Alignment Specifications
  • Too Many Alignment Specifiers

• Anonymous Namespace in Header File
• Arctangent Domain Error

• argument

  • Argument Too High
  • Argument Too Low
  • Inappropriate Argument to memcmp
  • Inappropriate Argument to <tgmath.h> Macro
  • Inappropriate Argument to Integer Constant Macro
  • Inconsistent Types of Arguments to <tgmath.h> Macro
  • Mismatched Argument Types
  • Preprocessing Directives in Macro Argument
  • std::move Argument is const
  • std::move Argument is Not Lvalue
  • Unreasonable Size Argument

• array

  • Array Parameter
  • Array Parameter Mismatch
  • Array to Pointer Conversion on Temporary Object
  • Array to Pointer Decay
  • Extern Array Without Size
  • Partially Uninitialized Array
  • Pointer to Variably-modified Array Type
  • Static Array Parameter
  • Unspecified Array Size with Designator Initialization
  • Use of Array Type
  • sizeof Array Parameter

• assembly

  • Assembly Pragma
  • Inline Assembly Code
  • Mixed Assembly and Code

• assignment

  • Assignment in Conditional
  • Expression Value Widened by Assignment
  • Inappropriate Assignment Operator Return
  • Inappropriate Assignment Type
  • Non-zero Error Code Assignment
  • Too Many Side Effects in Assignment
  • Useless Assignment

• Atomic Memory Order, Risky
• Atomic, Multiple Accesses of

B

• Backwards goto

• base class

  • Multiple Inheritance with Public Base Class
  • Multiple Inheritance with Too Many Protected Base Classes
  • Virtual and Non-Virtual Base Class
  • Virtual Base Class
  • Virtual Base Class not In Diamond

• Basic Numerical Type Used

• bit-field

  • Bit-field Signedness Not Explicit
  • Bit-field Too Short
  • Bit-field in Union
  • Inappropriate Bit-field Type

• Blocking in Critical Section
• Body Is Not Compound Statement
• Boolean switch Expression
• Braced Initializer with auto

• buffer

  • Buffer Overrun
  • Buffer Underrun
  • Tainted Buffer Access

C

• C atomic

  • Direct Access to Field of C Atomic Object
  • Inappropriate C Atomic Initialization
  • Use of C Atomic
  • Void C Atomic

• C generic

  • Excessive Macro Parameter Evaluation in C Generic
  • Implicit Pointer Type Conversion in Selection of C Generic
  • Inappropriate Association Type in C Generic
  • Inappropriate Selection Type in C Generic
  • Inconsistent Macro Parameter Evaluation in C Generic
  • Misplaced Default Association in C Generic
  • Missing Non-default Association in C Generic
  • Selection in C Generic not Expanded from Macro Parameters
  • Side Effects in C Generic Selection
  • Use of C Generic

• C string

  • C String
  • Unterminated C String

• C-style Cast

• case

  • Misplaced case
  • Too Few Cases in switch

• cast

  • Cast: Arithmetic Type/Void Pointer
  • Cast: Virtual Base to Derived
  • C-style Cast
  • Cast: Non-integer Arithmetic Type/Object Pointer
  • Cast: Object Pointers
  • Cast: reinterpret_cast
  • Cast Alters Value
  • Cast Removes const Qualifier
  • Cast Removes volatile Qualifier
  • Dangerous Function Cast
  • Varargs Function Cast

• catopen, Use of
• chroot without chdir
• chroot, Use of

• class

  • Multiple Inheritance with Private Interface Class
  • Multiple Inheritance with Protected Interface Class
  • Multiple Inheritance with Public Base Class
  • Multiple Inheritance with Too Many Protected Base Classes
  • override in final Class
  • typeid of Polymorphic Class Type
  • Virtual and Non-Virtual Base Class
  • Virtual Base Class
  • Virtual Base Class not In Diamond
  • virtual in final Class

• Code Before #include
• Coercion Alters Value
• Coercion: Integer Constant to Pointer
• CoLoadLibrary, Use of
• Comma Operator, Use of
• Command Injection

• comment

  • /* in Comment
  • // in Comment
  • C++ Comment in C
  • Comment Suggests Code Unfinished
  • Commented-out Code
  • Line Splicing in Comment

• comparison

  • Comparison of Unrelated Pointers
  • Inappropriate Comparison of Virtual Member Function

• condition

  • Condition Contains Side Effects
  • Condition Is Not Boolean
  • Malformed for-loop Condition
  • Too Many Side Effects in Condition

• Conditional Compilation
• Conflicting Lock Order

• confusing

  • Confusing Literal Suffix
  • Confusing Operator Overload

• const

  • Cast Removes const Qualifier
  • Non-const Global Variable
  • Non-const Local Static Variable
  • Non-const Predicate Function Object
  • Non-const String Literal
  • Parameter is const Reference to Smart Pointer
  • Pointed-to Type Could Be const
  • Returned Pointer Not Treated as const
  • std::move Argument is const
  • Variable Could Be const

• constructor

  • Implicit Constructor Shadowing
  • Move Constructor With Copy Semantics
  • Virtual Call in Constructor

• Continue Statement

• conversion

  • Array to Pointer Conversion on Temporary Object
  • Conversion from Function Pointer
  • Conversion Operator Not Explicit
  • Conversion to Function Pointer
  • Conversion to Type bool
  • Conversion: Pointer/Integer
  • Conversion: Pointer to Incomplete
  • Conversion: Void Pointer to Object Pointer
  • Float Pointer Conversion
  • Function Pointer Conversion
  • Implicit Pointer Type Conversion in Selection of C Generic

• Copy-Paste Error

• cosh

  • cosh on High Number
  • cosh on Low Number

• CreateFile, Use of
• CreateProcess, Use of
• CreateThread, Use of
• Critical Section, Blocking in

• cryptography

  • Encryption without Padding
  • Hardcoded Crypto Key
  • Hardcoded Crypto Salt
  • Use of crypt
  • Use of Weak Cryptographic Algorithm
  • Weak Cryptography

• crypt, Use of
• cuserid, Use of

D

• Dangerous Function Cast
• Dangerous Include File Name
• Data Race
• Deadlock

• declaration

  • Declaration of Reserved Name
  • Declaration of Variable Length Array
  • Implicit Function Declaration
  • Inappropriate Declaration in Global Namespace
  • Inappropriate Volatile Declaration
  • Inconsistent Function Declarations
  • Inconsistent Object Declarations
  • Missing External Declaration
  • Multiple External Declarations
  • No Previous Declaration
  • Using Declaration in Header File

• default

  • Default Initialization of Random Number Generator
  • Method Default Value Mismatch
  • Misplaced default
  • Misplaced Default Association in C Generic
  • Missing default
  • Missing Non-default Association in C Generic

• define

  • Function Defined in Header File
  • Macro Defined in Function Body
  • Macro Defines Constant
  • Missing User-defined Operations
  • Object Defined in Header File
  • User-defined Literal Operator

• definition

  • Missing External Definition
  • Multiple External Definitions

• delete

  • delete with Non-Virtual Destructor
  • Missing delete
  • Use of delete

• dereference

  • FILE* Dereference
  • Null Pointer Dereference
  • Too Many Dereferences
  • Unchecked Parameter Dereference

• designator

  • Inconsistent Chained Designator Initialization
  • Unspecified Array Size with Designator Initialization

• destructor

  • delete with Non-Virtual Destructor
  • Virtual Call in Destructor

• Diagnostic, Essential Type
• Direct Access to Field of C Atomic Object

• directive

  • Invalid Preprocessor Directive
  • Preprocessing Directives in Macro Argument
  • Using Directive
  • Using Directive in Header File

• Division By Zero

• domain error

  • Arctangent Domain Error
  • Floating Point Domain Error
  • see also MATH.DOMAIN.*

• Double Close
• Double Free
• Double Initialization
• Double Lock
• Double Unlock
• drem, Use of
• Dynamic Allocation After Initialization
• Dynamic Thread Creation

E

• Ellipsis

• empty

  • Empty Branch Statement
  • Empty for Statement
  • Empty if Statement
  • Empty switch Statement
  • Empty while Statement

• Encapsulation Violation

• encoding

  • Implicit Encoding in String Concatenation
  • Mixed Encodings in String Concatenation

• Encryption without Padding

• enumeration

  • Enumeration Has Implicit Underlying Type
  • Inconsistent Enumerator Initialization
  • switch With Non-enum Expression
  • Unscoped Enumeration

• Equality, Floating Point

• error code

  • Inappropriate Test of Error Code
  • Missing Test of Error Code
  • Non-zero Error Code
  • Non-zero Error Code Assignment

• Essential Type Diagnostic
• Excessive Macro Parameter Evaluation in C Generic
• Excessive Stack Depth
• _exec, Use of
• execlp, Use of
• Explicit Zero Alignment

• expression

  • Boolean switch Expression
  • Expression Value Widened by Assignment
  • Expression Value Widened by Other Operand
  • Inappropriate Cast Type: Expression
  • Non-Boolean Preprocessor Expression
  • Side Effects in Expression with Decrement
  • Side Effects in Expression with Increment
  • switch With Non-enum Expression

• execvp, Use of

• extension

  • GNU Extension
  • Microsoft Extension

• Extern Array Without Size

• external

  • Non-distinct Identifiers: External Names
  • Non-unique Identifiers: External Name

F

• field

  • Direct Access to Field of C Atomic Object
  • Unnamed Field
  • see also: bit-field

• file

  • Anonymous Namespace in Header File
  • Dangerous Include File Name
  • File Open for Both Read and Write
  • File System Race Condition
  • FILE* Dereference
  • Function Defined in Header File
  • Inappropriate Include File Specification
  • Negative file descriptor
  • Object Defined in Header File
  • Scope Could Be File Static
  • Tainted Filename
  • Use of CreateFile
  • Use of GetTempFileName
  • Use of tmpfile
  • Use of tmpfile_s
  • Use of MoveFile
  • Using Declaration in Header File
  • Using Directive in Header File
  • Write to Read Only File

• final

  • override in final Class
  • Virtual Function Missing virtual/override/final
  • virtual in final Class

• float

  • Float Division By Zero
  • Float Multiplication Overflow
  • Float Pointer Conversion
  • Float-typed Loop Counter
  • Floating Point Domain Error
  • Floating Point Equality
  • Floating Point Range Error

• for Statement, Empty
• Format String
• Format String Injection
• Format String Type Error
• FormatMessage, Use of
• Free Null Pointer
• Freed, Return Pointer To

• function

  • Dangerous Function Cast
  • Function-Like Macro
  • Function Call Has No Effect
  • Function Defined in Header File
  • Function Pointer
  • Function Pointer Conversion
  • Function Too Long
  • Implicit Function Declaration
  • Inappropriate Comparison of Virtual Member Function
  • Inappropriate throw in noexcept Function
  • Incomplete Function Prototype
  • Inconsistent Function Declarations
  • Inline Function Not static
  • Macro Defined in Function Body
  • Macro Undefined in Function Body
  • Nested Function Declaration
  • Non-const Predicate Function Object
  • Task Delay Function
  • Too Many Side Effects in Function Call
  • Type Qualifier on Function Type
  • Use of <cctype> Function
  • Use of <cwctype> Function
  • Use of <fenv.h> Signal Handling Function
  • Use of <time.h> Time/Date Function
  • Varargs Function Cast
  • Virtual Function Missing virtual/override/final

• Function-Like Macro
• Function Call Has No Effect
• Function Defined in Header File
• Function Pointer
• Function Pointer Conversion
• Function Too Long

G

• gamma

  • gamma on Zero
  • Use of gamma

• getlogin, Use of
• getopt, Use of
• getpass, Use of
• gets, Use of
• GetTempFileName, Use of
• getwd, Use of

• global

  • GlobalHandle on GMEM_FIXED Memory
  • GlobalLock on GMEM_FIXED Memory
  • GlobalUnlock on GMEM_FIXED Memory
  • Global Variable Declared with Different Types
  • Inappropriate Declaration in Global Namespace
  • Multiple Declarations of a Global
  • Non-const Global Variable
  • Use of std::locale::global

• GNU

  • GNU Extension
  • GNU Typeof

• Goto Statement

H

• Hardcoded Authentication
• Hardcoded DNS Name
• Hardcoded Crypto Key
• Hardcoded Crypto Salt

• header file

  • Anonymous Namespace in Header File
  • Function Defined in Header File
  • Object Defined in Header File
  • Using Declaration in Header File
  • Using Directive in Header File

• hexadecimal

  • Lower Case in Hexadecimal Literal

• High Risk Loop

I

• identifier

  • Non-distinct Identifiers: External Names
  • Non-distinct Identifiers: Macro/Macro
  • Non-distinct Identifiers: Macro/Other
  • Non-distinct Identifiers: Nested Scope
  • Non-distinct Identifiers: Same Scope
  • Non-unique Identifiers: External Name
  • Non-unique Identifiers: Internal Name
  • Non-unique Identifiers: Tag
  • Non-unique Identifiers: Typedef
  • Typographically Ambiguous Identifiers

• Ignored Return Value

• implicit

  • Enumeration Has Implicit Underlying Type
  • Implicit Address of Function
  • Implicit Constructor Shadowing
  • Implicit Encoding in String Concatenation
  • Implicit Function Declaration
  • Implicit Inheritance from Stateful Virtual Base
  • Implicit Lambda Capture
  • Implicit Lambda Capture of this
  • Implicit Pointer Type Conversion in Selection of C Generic
  • Unneeded Implicitly Generated Operations

• inappropriate

  • Inappropriate Argument to memcmp
  • Inappropriate Argument to <tgmath.h> Macro
  • Inappropriate Argument to Integer Constant Macro
  • Inappropriate Assignment Operator Return
  • Inappropriate Assignment Type
  • Inappropriate Association Type in C Generic
  • Inappropriate Bit-field Type
  • Inappropriate C Atomic Initialization
  • Inappropriate Cast Type
  • Inappropriate Cast Type: Expression
  • Inappropriate Character Arithmetic
  • Inappropriate Comparison of Virtual Member Function
  • Inappropriate Declaration in Global Namespace
  • Inappropriate Include File Specification
  • Inappropriate Operand Type
  • Inappropriate Selection Type in C Generic
  • Inappropriate Storage Duration
  • Inappropriate Test of Error Code
  • Inappropriate throw in noexcept Function
  • Inappropriate Volatile Declaration

• include

  • Code Before #include
  • Dangerous Include File Name
  • Inappropriate Include File Specification
  • Malformed #include
  • Use of #include
  • Use of #include_next
  • see also LANG.PREPROC.INCL.*

• Incomplete Function Prototype

• inconsistent

  • Inconsistent Alignment Specifications
  • Inconsistent Chained Designator Initialization
  • Inconsistent Enumerator Initialization
  • Inconsistent Function Declarations
  • Inconsistent Object Declarations
  • Inconsistent Macro Parameter Evaluation in C Generic
  • Inconsistent Types of Arguments to <tgmath.h> Macro

• Indeterminate Order of Evaluation

• inheritance

  • Implicit Inheritance from Stateful Virtual Base
  • see also: multiple inheritance

• initialization

  • Default Initialization of Random Number Generator
  • Double Initialization
  • Dynamic Allocation After Initialization
  • Inappropriate C Atomic Initialization
  • Inconsistent Enumerator Initialization
  • Inconsistent Chained Designator Initialization
  • Initialization Cycle
  • Malformed for-loop Initialization
  • Missing Braces in Initialization
  • Unordered Initialization

• initializer

  • Braced Initializer with auto
  • Out of Order Member Initializers
  • Side Effects in Initializer List

• Inline Assembly Code
• Inline Function Not static
• Input After Output Without Positioning
• Integer Overflow of Allocation Size
• Invalid Preprocessor Directive

K

• keyword

  • Macro Name is C Keyword
  • Register Keyword

L

• label

  • Label Not In Enclosing Block
  • Unused Label

• lambda

  • Implicit Lambda Capture
  • Implicit Lambda Capture of this
  • Lambda Has No Parameter List
  • Lambda Has No Return Type

• LDAP Injection
• Leak
• Leftover Debug Code
• Library Function Override
• Library Injection
• Line Splicing in Comment

• literal

  • Confusing Literal Suffix
  • Lower Case in Hexadecimal Literal
  • Missing Literal Suffix
  • Non-const String Literal
  • User-defined Literal Operator

• LoadLibrary, Use of

• local

  • Local Variable Passed to Thread
  • Non-const Local Static Variable
  • Return Pointer to Local
  • Scope Could Be Local Static

• lock

  • Conflicting Lock Order
  • Lock/Unlock Mismatch
  • Locked Twice
  • Missing Lock Acquisition
  • Missing Lock Release
  • Nested Locks
  • Unknown Lock

• logarithm

  • Logarithm on Negative Value
  • Logarithm on Zero

• loop

  • Float-typed Loop Counter
  • High Risk Loop
  • Malformed for-loop Condition
  • Malformed for-loop Initialization
  • Missing for-loop Step
  • Missing for-loop Termination
  • Multiple Abnormal Loop Exits
  • Potential Unbounded Loop

• longjmp, Use of
• Lower Case in Hexadecimal Literal

M

• macro

  • Excessive Macro Parameter Evaluation in C Generic
  • Function-Like Macro
  • Inappropriate Argument to <tgmath.h> Macro
  • Inappropriate Argument to Integer Constant Macro
  • Inconsistent Macro Parameter Evaluation in C Generic
  • Inconsistent Types of Arguments to <tgmath.h> Macro
  • Macro Argument is both Mixed and Expanded
  • Macro Defined in Function Body
  • Macro Defines Constant
  • Macro Definition of Reserved Name
  • Macro Does Not End With ) or }
  • Macro Does Not Start With ( or {
  • Macro Name is C Keyword
  • Macro Parameter Not Parenthesized
  • Macro Undefined in Function Body
  • Macro Undefinition of Reserved Name
  • Macro Uses -> Operator
  • Macro Uses [] Operator
  • Macro Uses Unary * Operator
  • Macro Uses # Operator
  • Macro Uses ## Operator
  • Non-distinct Identifiers: Macro/Macro
  • Non-distinct Identifiers: Macro/Other
  • Preprocessing Directives in Macro Argument
  • Recursive Macro
  • Selection in C Generic not Expanded from Macro Parameters
  • Use of #undef
  • Use of <stdint.h> Small Integer Constant Macro
  • Unused Macro
  • Variadic Macro

• Macro Defined in Function Body
• Macro Defines Constant
• Macro Definition of Reserved Name
• Macro Does Not End With ) or }
• Macro Does Not Start With ( or {
• Macro Name is C Keyword
• Macro Parameter Not Parenthesized
• Macro Undefined in Function Body
• Macro Undefinition of Reserved Name
• Macro Uses -> Operator
• Macro Uses [] Operator
• Macro Uses Unary * Operator
• Macro Uses # Operator
• Macro Uses ## Operator

• malformed

  • Malformed #include
  • Malformed for-loop Condition
  • Malformed for-loop Initialization
  • Malformed for-loop Step
  • Malformed switch Statement

• MAX_PATH Exceeded

• member function

  • Inappropriate Comparison of Virtual Member Function
  • Member Function Could Be const
  • Member Function Could Be static

• memset, Use of
• Memory Protection Removal
• Method Default Value Mismatch
• Microsoft Extension
• Misaligned Object

• mismatch

  • Array Parameter Mismatch
  • Mismatched Argument Types
  • Mismatched Operand Types

• misplaced

  • Misplaced case
  • Misplaced default
  • Misplaced Default Association in C Generic
  • Misplaced Digit Separator
  • Misplaced Return Statement
  • Misplaced Using Declaration

• missing

  • Missing Braces in Initialization
  • Missing break
  • Missing default
  • Missing delete
  • Missing External Declaration
  • Missing External Definition
  • Missing Final else
  • Missing for-loop Step
  • Missing for-loop Termination
  • Missing noexcept
  • Missing Literal Suffix
  • Missing Lock Acquisition
  • Missing Lock Release
  • Missing Non-default Association in C Generic
  • Missing noreturn Specifier
  • Missing Parentheses
  • Missing Return Statement
  • Missing Return Value
  • Missing Test of Error Code
  • Missing throw in operator new
  • Missing User-defined Operations

• mixed

  • Macro Argument is both Mixed and Expanded
  • Mixed Assembly and Code
  • Mixed Encodings in String Concatenation

• mkstemp, Use of
• mktemp, Use of
• Modified Parameter
• Modification of Standard Namespaces
• MoveFile, Use of
• Move Constructor With Copy Semantics

• multiple

  • Multiple Abnormal Loop Exits
  • Multiple Accesses of Atomic
  • Multiple Declarations of a Global
  • Multiple Declarations On Line
  • Multiple External Declarations
  • Multiple External Definitions
  • Multiple Return Statements
  • Multiple Statements On Line
  • see also: multiple inheritance

• multiple inheritance

  • Multiple Inheritance with Private Interface Class
  • Multiple Inheritance with Protected Interface Class
  • Multiple Inheritance with Public Base Class
  • Multiple Inheritance with Too Many Protected Base Classes

• multiplication

  • Float Multiplication Overflow
  • Multiplication Overflow of Allocation Size
  • Multiplication Overflow of Size

N

• namespace

  • Anonymous Namespace in Header File
  • Inappropriate Declaration in Global Namespace
  • Modification of Standard Namespaces

• Naming Style Violation

• negative

  • Logarithm on Negative Value
  • Negative Character Value
  • Negative file descriptor
  • Negative Shift Amount
  • Undefined Power of Zero
  • sqrt on Negative Value

• nested

  • Nested Conditional Operator
  • Nested Function Declaration
  • Nested Locks
  • Non-distinct Identifiers: Nested Scope

• new

  • Missing throw in operator new
  • Use of new

• No Matching #endif
• No Matching #if
• No Previous Declaration
• No Space For Null Terminator
• Non-Boolean Preprocessor Expression

• non-const

  • Non-const Global Variable
  • Non-const Local Static Variable
  • Non-const Predicate Function Object
  • Non-const String Literal

• non-distinct identifiers

  • Non-distinct Identifiers: External Names
  • Non-distinct Identifiers: Macro/Macro
  • Non-distinct Identifiers: Macro/Other
  • Non-distinct Identifiers: Nested Scope
  • Non-distinct Identifiers: Same Scope

• non-unique identifiers

  • Non-unique Identifiers: External Name
  • Non-unique Identifiers: Internal Name
  • Non-unique Identifiers: Tag
  • Non-unique Identifiers: Typedef

• Non-Virtual Method, Override of
• Non-void noreturn
• Non-zero Error Code
• Non-zero Error Code Assignment

• noreturn

  • Missing noreturn Specifier
  • Non-void noreturn
  • Return from noreturn
  • Use of Noreturn

• Not All Warnings are Enabled
• Not Enough Assertions

• null

  • Free Null Pointer
  • No Space For Null Terminator
  • Null Pointer Dereference
  • Null Security Descriptor
  • Null Test After Dereference
  • NULL Used as Integer
  • Read Past Null Terminator
  • Use of NULL

O

• object

  • Array to Pointer Conversion on Temporary Object
  • Direct Access to Field of C Atomic Object
  • Misaligned Object
  • Object Defined in Header File
  • Object Slicing
  • Non-const Predicate Function Object
  • Pointer Before Beginning of Object
  • Pointer Past End of Object

• Octal Constant
• OemToAnsi, Use of
• OemToChar, Use of

• operator

  • ## Follows # Operator
  • Confusing Operator Overload
  • Conversion Operator Not Explicit
  • Inappropriate Assignment Operator Return
  • Macro Uses # Operator
  • Macro Uses ## Operator
  • Macro Uses -> Operator
  • Macro Uses Unary * Operator
  • Macro Uses [] Operator
  • Missing throw in operator new
  • Nested Conditional Operator
  • Use of Comma Operator

• operation

  • Missing User-defined Operations
  • Unneeded Implicitly Generated Operations

• Out of Order Member Initializers
• Output After Input Without Positioning
• Over-initialized Element

• overflow

  Float Multiplication Overflow

  of allocation size

  • Addition Overflow of Allocation Size
  • Integer Overflow of Allocation Size
  • Multiplication Overflow of Allocation Size

  of size

  • Addition Overflow of Size
  • Multiplication Overflow of Size

• Overlapping Memory Regions

• override

  • Library Function Override
  • override in final Class
  • Override of Non-Virtual Method
  • Unnecessary override Specifier
  • Virtual Function Missing virtual/override/final

• overrun

  • Buffer Overrun
  • Type Overrun

P

• parameter

  • Array Parameter
  • Array Parameter Mismatch
  • Excessive Macro Parameter Evaluation in C Generic
  • Inconsistent Macro Parameter Evaluation in C Generic
  • Lambda Has No Parameter List
  • Macro Parameter Not Parenthesized
  • Modified Parameter
  • Parameter is const Reference to Smart Pointer
  • Selection in C Generic not Expanded from Macro Parameters
  • Static Array Parameter
  • Too Many Parameters
  • Unchecked Parameter Dereference
  • Unused Parameter
  • sizeof Array Parameter

• parenthesis

  • Macro Parameter Not Parenthesized
  • Missing Parentheses
  • Unbalanced Parenthesis

• Partially Uninitialized Aggregate
• Partially Uninitialized Array
• Plaintext Storage of Password
• Plaintext Transmission of Password
• Pointed-to Type Could Be const

• pointer

  • Array to Pointer Conversion on Temporary Object
  • Array to Pointer Decay
  • Cast: Arithmetic Type/Void Pointer
  • Cast: Non-integer Arithmetic Type/Object Pointer
  • Cast: Object Pointers
  • Comparison of Unrelated Pointers
  • Conversion: Pointer/Integer
  • Conversion: Pointer to Incomplete
  • Conversion: Void Pointer to Object Pointer
  • Free Null Pointer
  • Float Pointer Conversion
  • Function Pointer
  • Function Pointer Conversion
  • Implicit Pointer Type Conversion in Selection of C Generic
  • Null Pointer Dereference
  • Parameter is const Reference to Smart Pointer
  • Pointer Arithmetic
  • Pointer Before Beginning of Object
  • Pointer Past End of Object
  • Pointer to Variably-modified Array Type
  • Pointer Type Inside Typedef
  • Return Pointer to Freed
  • Return Pointer to Local
  • Returned Pointer Not Treated as const
  • Subtraction of Unrelated Pointers

• positioning

  • Input After Output Without Positioning
  • Output After Input Without Positioning

• popen, Use of
• Possible Anti-Debugging
• Potential Timebomb
• Potential Unbounded Loop
• Pragma, Assembly
• Preprocessing Directives in Macro Argument

Q

• qualifier

  • Restrict Qualifier Used
  • Type Qualifier on Function Type

R

• Raises FE_INVALID
• rand, Use of
• rand48 Function, Use of
• random, Use of

• range error

  • Floating Point Range Error
  • see also MATH.RANGE.*

• Read Past Null Terminator
• realpath, Use of
• Recursion
• Recursive Macro
• recvmsg, Use of
• Redundant Condition
• Register Keyword

• reserved name

  • Declaration of Reserved Name
  • Macro Definition of Reserved Name
  • Macro Undefinition of Reserved Name

• Restrict Qualifier Used

• return

  • Ignored Return Value
  • Inappropriate Assignment Operator Return
  • Lambda Has No Return Type
  • Misplaced Return Statement
  • Missing Return Statement
  • Missing Return Value
  • Multiple Return Statements
  • Return from noreturn
  • Return Pointer To Freed
  • Return Pointer to Local
  • Returned Pointer Not Treated as const

• Risky Atomic Memory Order
• Risky Integer Promotion

S

• Scope Could Be File Static
• Scope Could Be Local Static
• Selection in C Generic not Expanded from Macro Parameters
• setjmp, Use of
• setlocale, Use of
• setuid, Use of
• SHCreateProcessAsUserW, Use of
• ShellExecute, Use of

• shift

  • Negative Shift Amount
  • Shift Amount Exceeds Bit Width

• side effects

  • Condition Contains Side Effects
  • Side Effects in C Generic Selection
  • Side Effects in Expression with Decrement
  • Side Effects in Expression with Increment
  • Side Effects in Initializer List
  • Side Effects in Logical Operand
  • Side Effects in sizeof
  • Too Many Side Effects in Assignment
  • Too Many Side Effects in Function Call
  • Too Many Side Effects in Condition
  • Too Many Side Effects in Statement
  • Too Many Side Effects in Switch

• signal, Use of
• Size Argument, Unreasonable

• sizeof

  • Side Effects in sizeof
  • sizeof Array Parameter

• Socket In Wrong State
• _spawn, Use of
• Specialization after Use

• specification

  • Inappropriate Include File Specification
  • Inconsistent Alignment Specifications

• specifier

  • Missing noreturn Specifier
  • Too Many Alignment Specifiers
  • Unnecessary override Specifier
  • Unnecessary virtual Specifier

• SQL Injection
• sqrt on Negative Value

• statement

  • Body Is Not Compound Statement
  • Continue Statement
  • Empty Branch Statement
  • Empty for Statement
  • Empty if Statement
  • Empty switch Statement
  • Empty while Statement
  • Goto Statement
  • Malformed switch Statement
  • Misplaced Return Statement
  • Missing Return Statement
  • Multiple Return Statements
  • Multiple Statements On Line
  • Too Many Side Effects in Statement

• Static Array Parameter
• std::locale::global, Use of
• std::move Argument is const
• std::move Argument is Not Lvalue

• storage

  • Inappropriate Storage Duration
  • Plaintext Storage of Password

• strcat, Use of
• StrCatChainW, Use of
• strcmp, Use of
• strcpy, Use of

• string

  • C String
  • Format String
  • Format String Injection
  • Format String Type Error
  • Implicit Encoding in String Concatenation
  • Mixed Encodings in String Concatenation
  • Non-const String Literal
  • Unterminated C String

• strlen, Use of
• strtrns, Use of
• Subtraction of Unrelated Pointers
• Subtraction Underflow of Allocation Size
• Subtraction Underflow of Size

• suffix

  • Confusing Literal Suffix
  • Missing Literal Suffix

• switch

  • Boolean switch Expression
  • Empty switch Statement
  • Malformed switch Statement
  • switch With Non-enum Expression
  • Too Few Cases in switch
  • Too Many Side Effects in Switch

• syslog, Use of
• system, Use of

T

• t_open, Use of
• Tag, Unused

• tainted

  • Tainted Allocation Size
  • Tainted Buffer Access
  • Tainted Configuration Setting
  • Tainted Environment Variable
  • Tainted Filename
  • Tainted Network Address
  • Tainted Write

• Task Delay Function

• thread

  • Dynamic Thread Creation
  • Local Variable Passed to Thread
  • Thread Entry Point

• throw

  • Inappropriate throw in noexcept Function
  • Missing throw in operator new
  • Use of throw

• tmpfile, Use of
• tmpnam, Use of
• Too Few Cases in switch

• too many

  • Too Many Alignment Specifiers
  • Too Many Dereferences
  • Too Many Parameters
  • Too Many Side Effects in Assignment
  • Too Many Side Effects in Function Call
  • Too Many Side Effects in Condition
  • Too Many Side Effects in Statement
  • Too Many Side Effects in Switch

• Too Much Indirection in Declaration
• Trigraph
• Truncation of Allocation Size
• Truncation of Size
• Try-lock that will never succeed
• ttyname, Use of

• type

  • Basic Numerical Type Used
  • Cast: Arithmetic Type/Void Pointer
  • Cast: Non-integer Arithmetic Type/Object Pointer
  • Conversion to Type bool
  • Enumeration Has Implicit Underlying Type
  • Essential Type Diagnostic
  • Float-typed Loop Counter
  • Format String Type Error
  • Inappropriate Argument to memcmp
  • Inappropriate Argument to <tgmath.h> Macro
  • Inappropriate Assignment Type
  • Inappropriate Bit-field Type
  • Inappropriate Cast Type
  • Inappropriate Cast Type: Expression
  • Inappropriate Operand Type
  • Inconsistent Types of Arguments to <tgmath.h> Macro
  • Mismatched Operand Types
  • Pointed-to Type Could Be const
  • Pointer to Variably-modified Array Type
  • Type Mismatch
  • Type Overrun
  • Type Qualifier on Function Type
  • Type Underrun
  • typeid of Polymorphic Class Type
  • Unused Type
  • Use of Array Type
  • see also LANG.TYPE.*

• typedef

  • Non-unique Identifiers: Typedef
  • Pointer Type Inside Typedef

• typeid of Polymorphic Class Type
• Typeof, GNU
• Typographically Ambiguous Identifiers

U

• Unbalanced Parenthesis
• Unchecked Parameter Dereference

• undefined

  • Macro Undefined in Function Body
  • Undefined Power of Zero
  • Undefined Macro in #if

• Undefined Power of Zero
• Undefined Macro in #if

• underrun

  • Buffer Underrun
  • Type Underrun

• unexercised

  • Unexercised Call
  • Unexercised Computation
  • Unexercised Conditional
  • Unexercised Control Flow
  • Unexercised Data Flow

• uninitialized

  • Partially Uninitialized Aggregate
  • Partially Uninitialized Array
  • Uninitialized Variable

• union

  • Union Type
  • Bit-field in Union

• Unknown Lock
• Unnamed Field
• Unneeded Implicitly Generated Operations
• Unnecessary override Specifier
• Unnecessary virtual Specifier
• Unordered Initialization

• unreachable

  • Unreachable Call
  • Unreachable Catch
  • Unreachable Computation
  • Unreachable Conditional
  • Unreachable Control Flow
  • Unreachable Data Flow

• Unreasonable Size Argument
• Unscoped Enumeration
• Unspecified Array Size with Designator Initialization

• unterminated

  • Unterminated C String
  • Unterminated Escape Sequence

• untrusted

  • Untrusted Library Load
  • Untrusted Network Host
  • Untrusted Network Port
  • Untrusted Process Creation

• unused

  • Unused Label
  • Unused Macro
  • Unused Parameter
  • Unused Tag
  • Unused Type
  • Unused Value
  • Unused Variable

• Use After Close
• Use After Free
• Use of #define
• Use of #elif
• Use of #elifdef
• Use of #elifndef
• Use of #else
• Use of #endif
• Use of #error
• Use of #if
• Use of #ifdef
• Use of #ifndef
• Use of #import
• Use of #include
• Use of #include_next
• Use of #line
• Use of #pragma
• Use of #undef
• Use of #using
• Use of #warning
• Use of <cctype> Function
• Use of <cwctype> Function
• Use of <fenv.h> Signal Handling Function
• Use of <setjmp.h>
• Use of <signal.h>
• Use of <stdarg.h> Feature
• Use of <stdint.h> Small Integer Constant Macro
• Use of <stdio.h> Input/Output
• Use of <stdio.h> Input/Output Macro
• Use of <stdlib.h> Allocator/Deallocator
• Use of <stdlib.h> Allocator/Deallocator Macro
• Use of <tgmath.h>
• Use of <time.h> Time/Date Function
• Use of <wchar.h> Input/Output
• Use of <wchar.h> Input/Output Macro
• Use of _exec
• Use of _spawn
• Use of abort
• Use of abort_handler_s
• Use of AddAccessAllowedAce
• Use of AddAccessDeniedAce
• Use of AfxLoadLibrary
• Use of AfxParseURL
• Use of Alignas
• Use of Alignof
• Use of Array Type
• Use of asctime_s
• Use of atof
• Use of atoi
• Use of atol
• Use of atoll
• Use of bsearch
• Use of bsearch_s
• Use of catopen
• Use of C Atomic
• Use of C Generic
• Use of chroot
• Use of CoLoadLibrary
• Use of constraint_handler_t
• Use of Comma Operator
• Use of CreateFile
• Use of CreateProcess
• Use of CreateThread
• Use of crypt
• Use of ctime_s
• Use of cuserid
• Use of delete
• Use of drem
• Use of execlp
• Use of execvp
• Use of exit
• Use of fopen_s
• Use of FormatMessage
• Use of fprintf_s
• Use of freopen_s
• Use of fscanf_s
• Use of fwprintf_s
• Use of fwscanf_s
• Use of gamma
• Use of getenv
• Use of getenv_s
• Use of getlogin
• Use of getopt
• Use of getpass
• Use of gets
• Use of gets_s
• Use of GetTempFileName
• Use of getwd
• Use of gmtime_s
• Use of ignore_handler_s
• Use of LoadLibrary
• Use of LoadModule
• Use of localtime_s
• Use of longjmp
• Use of L_tmpnam_s
• Use of mbsrtowcs_s
• Use of mbstowcs_s
• Use of memcpy_s
• Use of memmove_s
• Use of memset
• Use of memset_s
• Use of mkstemp
• Use of mktemp
• Use of MoveFile
• Use of new
• Use of Noreturn
• Use of NULL
• Use of OemToAnsi
• Use of OemToChar
• Use of offsetof
• Use of popen
• Use of printf_s
• Use of qsort
• Use of qsort_s
• Use of rand
• Use of rand48 Function
• Use of random
• Use of realpath
• Use of recvmsg
• Use of scanf_s
• Use of set_constraint_handler_s
• Use of setjmp
• Use of setlocale
• Use of setuid
• Use of SHCreateProcessAsUserW
• Use of ShellExecute
• Use of signal
• Use of snprintf_s
• Use of snwprintf_s
• Use of SO_REUSEADDR
• Use of sprintf_s
• Use of sscanf_s
• Use of std::bind
• Use of std::locale::global
• Use of std::vector<bool>
• Use of strcat
• Use of strcat_s
• Use of StrCatChainW
• Use of strcmp
• Use of strcpy
• Use of strcpy_s
• Use of strerror_s
• Use of strerrorlen_s
• Use of strlen
• Use of strncat_s
• Use of strncpy_s
• Use of strnlen_s
• Use of strtok_s
• Use of strtrns
• Use of swprintf_s
• Use of swscanf_s
• Use of syslog
• Use of system
• Use of t_open
• Use of Thread Local
• Use of throw
• Use of TMP_MAX_S
• Use of tmpfile
• Use of tmpfile_s
• Use of tmpnam
• Use of tmpnam_s
• Use of ttyname
• Use of vfork
• Use of vfprintf_s
• Use of vfscanf_s
• Use of vfwprintf_s
• Use of vfwscanf_s
• Use of vprintf_s
• Use of vscanf_s
• Use of vsnprintf_s
• Use of vsnwprintf_s
• Use of vsprintf_s
• Use of vsscanf_s
• Use of vswprintf_s
• Use of vswscanf_s
• Use of vwprintf_s
• Use of vwscanf_s
• Use of Weak Cryptographic Algorithm
• Use of wcrtomb_s
• Use of wcscat_s
• Use of wcscpy_s
• Use of wcsncat_s
• Use of wcsncpy_s
• Use of wcsnlen_s
• Use of wcsrtombs_s
• Use of wcstok_s
• Use of wcstombs_s
• Use of wctomb_s
• Use of wmemcpy_s
• Use of wmemmove_s
• Use of wprintf_s
• Use of wscanf_s
• Use of XML_ExternalEntityParserCreate
• Useless Assignment

• user-defined

  • Missing User-defined Operations
  • User-defined Literal Operator

• using

  • Misplaced Using Declaration
  • Using Declaration in Header File
  • Using Directive
  • Using Directive in Header File

V

• Varargs Function Cast

• variable

  • Declaration of Variable Length Array
  • Global Variable Declared with Different Types
  • Local Variable Passed to Thread
  • Non-const Global Variable
  • Non-const Local Static Variable
  • Tainted Environment Variable
  • Uninitialized Variable
  • Unused Variable
  • Variable Could Be const

• Variable Could Be const
• Variadic Macro
• vfork, Use of

• virtual

  • delete with Non-Virtual Destructor
  • Cast: Virtual Base to Derived
  • Implicit Inheritance from Stateful Virtual Base
  • Inappropriate Comparison of Virtual Member Function
  • Override of Non-Virtual Method
  • Unnecessary virtual Specifier
  • Virtual and Non-Virtual Base Class
  • Virtual Base Class
  • Virtual Base Class not In Diamond
  • Virtual Call in Constructor
  • Virtual Call in Destructor
  • Virtual Function Missing virtual/override/final
  • virtual in final Class

• void

  • Cast: Arithmetic Type/Void Pointer
  • Conversion: Void Pointer to Object Pointer
  • Non-void noreturn
  • Void C Atomic

• volatile

  • Cast Removes volatile Qualifier
  • Inappropriate Volatile Declaration

W

• Warnings Not Treated as Errors
• Weak Cryptographic Algorithm, Use of
• Weak Cryptography
• Write to Read Only File

X

• XML_ExternalEntityParserCreate, Use of

Z

• zero

  • Division By Zero
  • Explicit Zero Alignment
  • Float Division By Zero
  • Gamma on Zero
  • Logarithm on Zero
  • Undefined Power of Zero