Merge pull request MicrosoftDocs#4516 from MugBergerFries/patch-12

Updated Reliability MinBar Warnings (WIP)

Author: colin-home

docs/code-quality/c6064.md

@@ -1,59 +1,48 @@
 ---
 description: "Learn more about: C6064"
 title: C6064
-ms.date: 11/04/2016
+ms.date: 09/14/2022
 ms.topic: reference
-f1_keywords: ["C6064"]
+f1_keywords: ["C6064", "MISSING_INTEGER_ARGUMENT_TO_FORMAT_FUNCTION", "__WARNING_MISSING_INTEGER_ARGUMENT_TO_FORMAT_FUNCTION"]
 helpviewer_keywords: ["C6064"]
 ms.assetid: d8f126aa-b093-440e-820f-65b8e6cffaba
 ---
-# C6064
+# Warning C6064
 
-> warning C6064: missing integer argument to \<function> corresponding to conversion specifier \<number>
+> Missing integer argument to '*function-name*' corresponding to conversion specifier '*number*'
 
-This warning indicates that not enough arguments are being provided to match a format string and one of the missing arguments is an integer. This defect can cause incorrect output.
+This warning indicates that not enough arguments are being provided to match a format string and one of the missing arguments is an integer.
 
-## Example
+## Remarks
 
-The following code generates this warning because an incorrect number of arguments were used in call to `sprintf` and the missing argument was an integer:
+This defect is likely to cause incorrect output and, in more dangerous cases, can lead to stack overflow.
 
-```cpp
-#include <string.h>
-void f( )
-{
-  char buff[15];
-  char *string="Hello, World";
+Code analysis name: MISSING_INTEGER_ARGUMENT_TO_FORMAT_FUNCTION
 
-  sprintf(buff,"%s %d", string);
-}
-```
+## Example
 
-To correct this warning, specify missing arguments as shown in the following code:
+The following code generates this warning because an incorrect number of arguments were used in the call to `sprintf_s` and the missing argument was an integer. Had the unsafe function `sprintf` been used instead of the safer variant `sprintf_s`, this code would likely cause a stack overflow instead of just an unexpected output:
 
 ```cpp
-#include <string.h>
-void f( )
+void f()
 {
-  char buff[15];
-  char *string = "Hello, World";
-
-  sprintf(buff,"%s %d",string, strlen(string));
+    char buff[8];
+    char *string="Hello";
+    sprintf_s(buff, sizeof(buff), "%s %d", string);  // Attempts to print "Hello 256" or approximate, which cannot fit in the 8 char buffer. This would overflow if sprintf had been used instead
 }
 ```
 
-The following code uses safe string manipulation function, `sprintf_s` to correct this warning:
+To correct this warning, specify missing arguments as shown in the following code:
 
 ```cpp
-#include <string.h>
-void f( )
+void f()
 {
-  char buff[15];
-  char *string="Hello World";
-
-  sprintf_s(buff,sizeof(buff),"%s %d", string, strlen(string));
+    char buff[8];
+    char *string = "Hello";
+    sprintf_s(buff, sizeof(buff), "%s %d", string, strlen(string));
 }
 ```
 
 ## See also
 
-[sprintf_s, _sprintf_s_l, swprintf_s, _swprintf_s_l](../c-runtime-library/reference/sprintf-s-sprintf-s-l-swprintf-s-swprintf-s-l.md)
+[sprintf_s, _sprintf_s_l, swprintf_s, _swprintf_s_l](/cpp/c-runtime-library/reference/sprintf-s-sprintf-s-l-swprintf-s-swprintf-s-l)

docs/code-quality/c6270.md

@@ -1,59 +1,47 @@
 ---
 description: "Learn more about: C6270"
 title: C6270
-ms.date: 11/04/2016
+ms.date: 09/14/2022
 ms.topic: reference
-f1_keywords: ["C6270"]
+f1_keywords: ["C6270", "MISSING_FLOAT_ARGUMENT_TO_FORMAT_FUNCTION", "__WARNING_MISSING_FLOAT_ARGUMENT_TO_FORMAT_FUNCTION"]
 helpviewer_keywords: ["C6270"]
 ms.assetid: 34467f6e-98cf-489c-ae5e-c08a744d86c3
 ---
-# C6270
+# Warning C6270
 
-> warning C6270: missing float argument to \<function>: add a float argument corresponding to conversion specifier \<number>
+> Missing float argument to '*function-name*': add a float argument corresponding to conversion specifier '*number*'
 
-This warning indicates that not enough arguments are being provided to match a format string; at least one of the missing arguments is a floating-point number. This defect can lead to crashes, in addition to potentially incorrect output.
+This warning indicates that not enough arguments are being provided to match a format string; at least one of the missing arguments is a floating-point number.
 
-## Example
+## Remarks
 
-The following code generates this warning:
+This defect can lead to crashes, in addition to potentially incorrect output.
 
-```cpp
-#include <stdio.h>
-#include <string.h>
+Code analysis name: MISSING_FLOAT_ARGUMENT_TO_FORMAT_FUNCTION
 
-void f()
-{
-  char buff [25];
-  sprintf(buff,"%s %f","pi:");
-}
-```
+## Example
 
-To correct this warning, pass the missing argument as shown in the following code:
+The following code generates this warning. `sprintf_s` expects a second float argument as denoted by `%f` but none is provided:
 
 ```cpp
-#include <stdio.h>
-#include <string.h>
-
 void f()
 {
-  char buff [25];
-  sprintf(buff,"%s %f","pi:",3.1415);
+    char buff [25];
+    sprintf_s(buff, sizeof(buff), "%s %f", "pi: ");
 }
 ```
 
-The following sample code uses the safe string manipulation function, `sprintf_s`, to correct this warning:
+To correct this warning, pass the missing float argument as shown in the following code:
 
 ```cpp
-#include <stdio.h>
-#include <string.h>
-
 void f()
 {
-  char buff [25];
-  sprintf_s( buff, 25,"%s %f", "pi:",3.1415 );
+    char buff [25];
+    sprintf_s(buff, sizeof(buff), "%s %f", "pi: ", 3.14159);
 }
 ```
 
 ## See also
 
-[sprintf, _sprintf_l, swprintf, _swprintf_l, \__swprintf_l](../c-runtime-library/reference/sprintf-sprintf-l-swprintf-swprintf-l-swprintf-l.md)
+[sprintf, _sprintf_l, swprintf, _swprintf_l, \__swprintf_l](../c-runtime-library/reference/sprintf-sprintf-l-swprintf-swprintf-l-swprintf-l.md)\
+[sprintf_s, _sprintf_s_l, swprintf_s, _swprintf_s_l](/cpp/c-runtime-library/reference/sprintf-s-sprintf-s-l-swprintf-s-swprintf-s-l)

docs/code-quality/c6272.md

@@ -1,65 +1,44 @@
 ---
 description: "Learn more about: C6272"
 title: C6272
-ms.date: 11/04/2016
+ms.date: 09/15/2022
 ms.topic: reference
-f1_keywords: ["C6272"]
+f1_keywords: ["C6272", "NON_FLOAT_ARGUMENT_TO_FORMAT_FUNCTION", "__WARNING_NON_FLOAT_ARGUMENT_TO_FORMAT_FUNCTION"]
 helpviewer_keywords: ["C6272"]
 ms.assetid: b63937ac-fbb2-45ec-936a-641c156e6355
 ---
-# C6272
+# Warning C6272
 
-> warning C6272: non-float passed as argument \<number> when float is required in call to \<function>
+> Non-float passed as argument '*number*' when float is required in call to '*function-name*'
 
-This warning indicates that the format string specifies that a float is required, for example, a `%f` or `%g` specification for `printf,` but a non-float such as an integer or string is being passed. This defect is likely to result in incorrect output; however, in certain circumstances it could result in a crash.
+This warning indicates that the format string specifies that a float is required, for example, a `%f` or `%g` specification for `printf,` but a non-float such as an integer or string is being passed.
 
-## Example
-
-The following code generates this warning:
+## Remarks
 
-```cpp
-#include <stdio.h>
-#include <string.h>
+This defect is likely to result in incorrect output and, in certain circumstances, could result in a crash.
 
-void f()
-{
-   char buff[5];
-   int i=5;
+Code analysis name: NON_FLOAT_ARGUMENT_TO_FORMAT_FUNCTION
 
-   sprintf(buff,"%s %f","a",i);
-}
-```
+## Example
 
-To correct this warning, use `%i` instead of `%f` specification as shown in the following code:
+The following code generates this warning. `%f` indicates a float is expected, but the integer `i` is passed instead:
 
 ```cpp
-#include <stdio.h>
-#include <string.h>
-
 void f()
 {
-   char buff[5];
-   int i=5;
-
-   sprintf(buff,"%s %i","a",i);
+     char buff[5];
+     int i=5;
+     sprintf_s(buff, sizeof(buff), "%s %f", "a", i);
 }
 ```
 
-The following code uses the safe string manipulation function, `sprintf_s`, to correct this warning:
+To correct this warning, use `%i` instead of `%f` specification as shown in the following code:
 
 ```cpp
-#include <stdio.h>
-#include <string.h>
-
 void f()
 {
-   char buff[5];
-   int i=5;
-
-   sprintf_s(buff,5,"%s %i","a",i); // safe version
+     char buff[5];
+     int i=5;
+     sprintf_s(buff, sizeof(buff), "%s %i", "a", i);
 }
 ```
-
-## See also
-
-[sprintf, _sprintf_l, swprintf, _swprintf_l, \__swprintf_l](../c-runtime-library/reference/sprintf-sprintf-l-swprintf-swprintf-l-swprintf-l.md)

docs/code-quality/c6279.md

@@ -1,29 +1,29 @@
 ---
 description: "Learn more about: C6279"
 title: C6279
-ms.date: 11/04/2016
+ms.date: 09/15/2022
 ms.topic: reference
-f1_keywords: ["C6279"]
+f1_keywords: ["C6279", "NEW_ARRAY_DELETE_MISMATCH", "__WARNING_NEW_ARRAY_DELETE_MISMATCH"]
 helpviewer_keywords: ["C6279"]
 ms.assetid: 0af88b58-35df-456f-8c02-e8eeffe3b7de
 ---
-# C6279
+# Warning C6279
 
-> warning C6279: \<variable> is allocated with scalar new, deleted with array delete []
+> '*variable-name*' is allocated with scalar new, deleted with array delete []
 
-This warning appears only in C++ code and indicates that the calling function has inconsistently allocated memory with the scalar **`new`** operator, but freed it with the array **delete []** operator. If memory is allocated with scalar **`new`**, it should typically be freed with scalar **`delete`**.
+This warning appears only in C++ code and indicates that the calling function has inconsistently allocated memory with the scalar `new` operator, but freed it with the array `delete[]` operator. If memory is allocated with scalar `new`, it should typically be freed with scalar `delete`.
 
-There are at least three reasons that this is likely to cause problems:
+## Remarks
 
-- The constructors for the individual objects in the array are not invoked, although the destructors are.
+The exact ramifications of this defect are difficult to predict. It might cause random behavior or crashes due to usage of uninitialized memory as constructors aren't invoked. Or, it might cause memory allocations and crashes in situations where operators have been overridden. The analysis tool doesn't currently distinguish between these situations.
 
-- If global (or class-specific) **operator new** and **operator delete** are not compatible with **operator new[]** and **operator delete[]**, unexpected results are likely to occur.
+To avoid these kinds of allocation problems altogether, use the mechanisms that are provided by the C++ Standard Template Library (STL). These include [shared_ptr](../standard-library/shared-ptr-class.md), [unique_ptr](../standard-library/unique-ptr-class.md), and [vector](../standard-library/vector.md). For more information, see [Smart Pointers](../cpp/smart-pointers-modern-cpp.md) and [C++ Standard Library](../standard-library/cpp-standard-library-reference.md).
 
-The exact ramifications of this defect are difficult to predict. It might cause random behavior or crashes due to usage of uninitialized memory because constructors are not invoked. Or, it might cause memory allocations and crashes in situations where operators have been overridden. In rare cases, the mismatch might be unimportant. Analysis tool does not currently distinguish between these situations.
+Code analysis name: NEW_ARRAY_DELETE_MISMATCH
 
 ## Example
 
-The following code generates this warning:
+The following code generates this warning. `A` is allocated using `new` but deleted using `delete[]`:
 
 ```cpp
 class A
@@ -39,7 +39,7 @@ void f ( )
 }
 ```
 
-To correct this warning, use the following code:
+The following code remediates this warning by using `delete` instead:
 
 ```cpp
 void f( )
@@ -50,8 +50,6 @@ void f( )
 }
 ```
 
-To avoid these kinds of allocation problems altogether, use the mechanisms that are provided by the C++ Standard Template Library (STL). These include [shared_ptr](../standard-library/shared-ptr-class.md), [unique_ptr](../standard-library/unique-ptr-class.md), and [vector](../standard-library/vector.md). For more information, see [Smart Pointers](../cpp/smart-pointers-modern-cpp.md) and [C++ Standard Library](../standard-library/cpp-standard-library-reference.md).
-
 ## See also
 
 - [C6014](../code-quality/c6014.md)

docs/code-quality/c6280.md

@@ -1,23 +1,29 @@
 ---
 description: "Learn more about: C6280"
 title: C6280
-ms.date: 11/04/2016
+ms.date: 09/15/2022
 ms.topic: reference
-f1_keywords: ["C6280"]
+f1_keywords: ["C6280", "MEMORY_ALLOCATION_MISMATCH", "__WARNING_MEMORY_ALLOCATION_MISMATCH"]
 helpviewer_keywords: ["C6280"]
 ms.assetid: b91f2966-0876-4c9b-843a-e142f35be864
 ---
-# C6280
+# Warning C6280
 
-> warning C6280: \<variable> is allocated with \<function>, but deleted with \<function>
+> '*variable-name*' is allocated with '*function-name', but deleted with '*function-name*'
 
-This warning indicates that the calling function has inconsistently allocated memory by using a function from one memory allocation family and freed it by using a function from another memory allocation family. The analyzer checks for this condition only when the `_Analysis_mode_(_Analysis_local_leak_checks_)` SAL annotation is specified. By default, this annotation is specified for Windows kernel mode (driver) code. For more information about SAL annotations, see [Using SAL Annotations to Reduce C/C++ Code Defects](../code-quality/using-sal-annotations-to-reduce-c-cpp-code-defects.md).
+This warning indicates that the calling function has inconsistently allocated memory by using a function from one family and freed it by using a function from another.
 
-For example, this warning would be produced if memory is allocated by using `malloc` but freed by using `GlobalFree` or **`delete`**. In the specific cases of mismatches between array `new[]` and scalar **`delete`**, more precise warnings are reported instead of this one.
+## Remarks
+
+The analyzer checks for this condition only when the `_Analysis_mode_(_Analysis_local_leak_checks_)` SAL annotation is specified. By default, this annotation is specified for Windows kernel mode (driver) code. For more information about SAL annotations, see [Using SAL Annotations to Reduce C/C++ Code Defects](../code-quality/using-sal-annotations-to-reduce-c-cpp-code-defects.md).
+
+For example, this warning would be produced if memory is allocated by using `malloc` but freed by using `GlobalFree` or `delete`. In the specific cases of mismatches between array `new[]` and scalar `delete`, more precise warnings are reported instead of this one.
+
+Code analysis name: MEMORY_ALLOCATION_MISMATCH
 
 ## Example
 
-The following sample code generates this warning.
+The following sample code generates this warning. `pInt` is allocated using `calloc` but is freed using the mismatched function `delete`:
 
 ```cpp
 // cl.exe /analyze /c /EHsc /nologo /W4
@@ -34,7 +40,7 @@ void f(int arraySize)
 }
 ```
 
-To correct this warning, use this code:
+The following code remediates this warning by using the deallocation function `free`, the match to `calloc`:
 
 ```cpp
 // cl.exe /analyze /c /EHsc /nologo /W4
@@ -51,9 +57,11 @@ void f(int arraySize)
 }
 ```
 
-Different API definitions can use different heaps. For example, `GlobalAlloc` uses the system heap, and `free` uses the process heap. This is likely to cause memory corruptions and crashes.
+Different API definitions can use different heaps. For example, `GlobalAlloc` uses the system heap, and `free` uses the process heap. This issue is likely to cause memory corruptions and crashes.
+
+These inconsistencies apply to the `new`/`delete` and `malloc`/`free` memory allocation mechanisms. To avoid these kinds of potential inconsistencies altogether, use the mechanisms that are provided by the C++ Standard Template Library (STL). These include [shared_ptr](../standard-library/shared-ptr-class.md), [unique_ptr](../standard-library/unique-ptr-class.md), and [vector](../standard-library/vector.md). For more information, see [Smart Pointers](../cpp/smart-pointers-modern-cpp.md) and [C++ Standard Library](../standard-library/cpp-standard-library-reference.md).
 
-These inconsistencies apply to the **`new`**/**`delete`** and `malloc`/`free` memory allocation mechanisms. To avoid these kinds of potential inconsistencies altogether, use the mechanisms that are provided by the C++ Standard Template Library (STL). These include [shared_ptr](../standard-library/shared-ptr-class.md), [unique_ptr](../standard-library/unique-ptr-class.md), and [vector](../standard-library/vector.md). For more information, see [Smart Pointers](../cpp/smart-pointers-modern-cpp.md) and [C++ Standard Library](../standard-library/cpp-standard-library-reference.md).
+The following code avoids this problem entirely by using `unique_ptr`:
 
 ```cpp
 // cl.exe /analyze /c /EHsc /nologo /W4