Consistency pass on some CQ warnings

Author: colin-home

docs/code-quality/c28208.md

@@ -1,7 +1,7 @@
 ---
 description: "Learn more about: C28208"
 title: C28208
-ms.date: 08/30/2022
+ms.date: 10/03/2022
 ms.topic: reference
 f1_keywords: ["C28208", "FUNCTION_TYPE_REDECLARATION", "__WARNING_FUNCTION_TYPE_REDECLARATION"]
 helpviewer_keywords: ["C28208"]
@@ -13,27 +13,26 @@ ms.assetid: e9a8ce37-3b05-4202-b078-5570ae496d1d
 
 ## Remarks
 
-This warning will almost always accompany [Compiler Warning (level 1) C4028](/cpp/error-messages/compiler-warnings/compiler-warning-level-1-c4028). Both warn of a mismatch between the parameters of a function's declaration and its definition. However, this specific error indicates a more niche case than C4028. C28208 indicates not only that a mismatch exists, but that it also can cause issues with analysis tools. This warning most notably occurs when the mismatch exists between a `typedef` function pointer and the definition of that function. This warning is demonstrated in the example below.
+This warning almost always accompanies [Compiler Warning (level 1) C4028](../error-messages/compiler-warnings/compiler-warning-level-1-c4028.md). Both warn of a mismatch between the parameters of a function's declaration and its definition. However, this specific error indicates a more niche case than C4028. C28208 indicates not only that a mismatch exists, but that it also can cause issues with analysis tools. This warning most notably occurs when the mismatch exists between a `typedef` function pointer and the definition of that function. This warning is demonstrated in the example below.
 
-Code analysis name: FUNCTION_TYPE_REDECLARATION
+Code analysis name: `FUNCTION_TYPE_REDECLARATION`
 
 ## Example
 
-The following code will generate C28208. `test_type` takes in a void pointer in its declaration, but `my_test1` takes in an integer pointer instead. `my_test2` remediates this issue by making sure the definition parameter match the declaration parameters.
-
-*From example.h:*
+The following code generates C28208. `test_type` declares `my_test1` and `my_test2` to take a `void*` parameter, but the definition of `my_test1` takes an `int*` parameter instead. `my_test2` avoids this issue because the definition parameters match the declaration parameters.
 
 ```cpp
+// c28208_example.h
 typedef void test_type(void*);
 ```
 
-*From example.cpp:*
-
 ```cpp
+// c28208_example.cpp
+#include "c28208_example.h"
 test_type my_test1;
 test_type my_test2;
-void my_test1(int* x){};  // Will generate C28208
-void my_test2(void* x){};  // Will not generate C28208
+void my_test1(int* x){};  // Generates C28208
+void my_test2(void* x){};  // Doesn't generate C28208
 
 int main()
 {

docs/code-quality/c6014.md

@@ -1,21 +1,25 @@
 ---
-description: "Learn more about: C6014"
-title: C6014
-ms.date: 11/04/2016
+description: "Learn more about: Warning C6014"
+title: Warning C6014
+ms.date: 10/03/2022
 ms.topic: reference
-f1_keywords: ["C6014"]
+f1_keywords: ["C6014", "MEMORY_LEAK", "__WARNING_MEMORY_LEAK"]
 helpviewer_keywords: ["C6014"]
 ms.assetid: ef76ec88-74d2-4a3b-b6fe-4b0851ab3372
 ---
-# C6014
+# Warning C6014
 
 > warning C6014: Leaking memory.
 
-This warning indicates that the specified pointer points to allocated memory or some other allocated resource that has not been freed. 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 specified pointer points to allocated memory or some other allocated resource that hasn't been freed.
+
+## 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).
 
 ## Examples
 
-The following code generates this warning:
+The following code generates warning C6014:
 
 ```cpp
 // cl.exe /analyze /EHsc /nologo /W4
@@ -72,11 +76,11 @@ int main( )
 }
 ```
 
-This warning is reported for both memory and resource leaks when the resource is commonly *aliased* to another location. Memory is aliased when a pointer to the memory escapes the function by means of an `_Out_` parameter annotation, global variable, or return value. This warning can be reported on function exit if the argument is annotated as having been expected to be released.
+This warning is reported for both memory and resource leaks when the resource is commonly *aliased* to another location. Memory is aliased when a pointer to the memory escapes the function by using an `_Out_` parameter annotation, global variable, or return value. This warning can be reported on function exit if the argument is annotated that its release is expected.
 
-Note that Code Analysis will not recognize the actual implementation of a memory allocator (involving address arithmetic) and will not recognize that memory is allocated (although many wrappers will be recognized). In this case, the analyzer does not recognize that the memory was allocated and issues this warning. To suppress the false positive, use a `#pragma` directive on the line that precedes the opening brace `{` of the function body.
+Code Analysis won't recognize the actual implementation of a memory allocator (involving address arithmetic) and won't recognize that memory is allocated (although many wrappers will be recognized). In this case, the analyzer doesn't recognize that the memory was allocated and issues this warning. To suppress the false positive, use a `#pragma` directive on the line that precedes the opening brace `{` of the function body.
 
-To avoid these kinds of potential leaks 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).
+To avoid these kinds of potential leaks altogether, use the mechanisms that are provided by the C++ Standard Library (STL). These include [`shared_ptr`](../standard-library/shared-ptr-class.md), [`unique_ptr`](../standard-library/unique-ptr-class.md), and containers such as [`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).
 
 ```cpp
 // cl.exe /analyze /EHsc /nologo /W4
@@ -110,4 +114,4 @@ int main( )
 
 ## See also
 
-[C6211](../code-quality/c6211.md)
+[Warning C6211](../code-quality/c6211.md)

docs/code-quality/c6064.md

@@ -1,7 +1,7 @@
 ---
-description: "Learn more about: C6064"
-title: C6064
-ms.date: 09/14/2022
+description: "Learn more about: Warning C6064"
+title: Warning C6064
+ms.date: 10/03/2022
 ms.topic: reference
 f1_keywords: ["C6064", "MISSING_INTEGER_ARGUMENT_TO_FORMAT_FUNCTION", "__WARNING_MISSING_INTEGER_ARGUMENT_TO_FORMAT_FUNCTION"]
 helpviewer_keywords: ["C6064"]
@@ -11,24 +11,28 @@ ms.assetid: d8f126aa-b093-440e-820f-65b8e6cffaba
 
 > 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 warning indicates that not enough arguments are provided to match a format string and one of the missing arguments is an integer.
 
 ## Remarks
 
 This defect is likely to cause incorrect output and, in more dangerous cases, can lead to stack overflow.
 
-Code analysis name: MISSING_INTEGER_ARGUMENT_TO_FORMAT_FUNCTION
+Code analysis name: `MISSING_INTEGER_ARGUMENT_TO_FORMAT_FUNCTION`
 
 ## Example
 
-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:
+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. If the unsafe function `sprintf` was used instead of the safer variant `sprintf_s`, this code would likely cause a stack overflow instead of just an unexpected output:
 
 ```cpp
 void f()
 {
     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
+    sprintf_s(buff, sizeof(buff), "%s %d", string);  // Attempts to print "Hello "
+    // followed by a number up to eleven characters long, depending on the garbage
+    // found on the stack. Any number other than a single non-negative digit can't
+    // fit in the 8 char buffer and leave room for the trailing null. If sprintf 
+    // had been used instead, it would overflow.
 }
 ```
 
@@ -45,4 +49,4 @@ void f()
 
 ## See also
 
-[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)
+[`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)

docs/code-quality/c6211.md

@@ -1,21 +1,27 @@
 ---
 description: "Learn more about: C6211"
 title: C6211
-ms.date: 11/04/2016
+ms.date: 10/03/2022
 ms.topic: reference
-f1_keywords: ["C6211"]
+f1_keywords: ["C6211", "MEMORY_LEAK_EXCEPTION", "__WARNING_MEMORY_LEAK_EXCEPTION"]
 helpviewer_keywords: ["C6211"]
 ms.assetid: 9b68243b-534c-4a05-b789-bb155dfcba1e
 ---
 # C6211
 
-> warning C6211: Leaking memory \<pointer> due to an exception. Consider using a local catch block to clean up memory
+> warning C6211: Leaking memory '*pointer*' due to an exception. Consider using a local catch block to clean up memory
 
-This warning indicates that allocated memory is not being freed when an exception is thrown. The statement at the end of the path could throw an exception. 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 allocated memory isn't freed when an exception is thrown. The statement at the end of the path could throw an exception.
+
+## 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).
+
+Code analysis name: `MEMORY_LEAK_EXCEPTION`
 
 ## Example
 
-The following code generates this warning because an exception could be thrown during the second allocation and thereby leak the first allocation, or an exception could be thrown somewhere in the code that's represented by the "`code ...`" comment and thereby leak both allocations.
+The following code generates warning C6211 because an exception could be thrown during the second allocation and thereby leak the first allocation. Or, an exception could be thrown somewhere in the code that's represented by the "`code ...`" comment and thereby leak both allocations.
 
 ```cpp
 // cl.exe /analyze /c /EHsc /nologo /W4
@@ -70,7 +76,7 @@ void f()
 }
 ```
 
-To avoid these kinds of potential leaks 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).
+To avoid these kinds of potential leaks altogether, use the mechanisms that are provided by the C++ Standard Library (STL). These include [`shared_ptr`](../standard-library/shared-ptr-class.md), [`unique_ptr`](../standard-library/unique-ptr-class.md), and containers such as [`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).
 
 ```cpp
 // cl.exe /analyze /c /EHsc /nologo /W4
@@ -107,4 +113,4 @@ void f( )
 
 ## See also
 
-[C++ Exception Handling](../cpp/exception-handling-in-visual-cpp.md)
+[C++ exception handling](../cpp/exception-handling-in-visual-cpp.md)

docs/code-quality/c6214.md

@@ -1,21 +1,27 @@
 ---
-description: "Learn more about: C6214"
-title: C6214
-ms.date: 11/04/2016
+description: "Learn more about: Warning C6214"
+title: Warning C6214
+ms.date: 10/03/2022
 ms.topic: reference
-f1_keywords: ["C6214"]
+f1_keywords: ["C6214", "CAST_HRESULT_TO_BOOL", "__WARNING_CAST_HRESULT_TO_BOOL"]
 helpviewer_keywords: ["C6214"]
 ms.assetid: 233e2395-61c1-4a3b-a54b-f19a9ffc31a8
 ---
-# C6214
+# Warning C6214
 
-> warning C6214: cast between semantically different integer types: HRESULT to a Boolean type
+> Cast between semantically different integer types: HRESULT to a Boolean type
 
-This warning indicates that an `HRESULT` is being cast to a Boolean type. The success value (`S_OK`) of an `HRESULT` equals 0. However, 0 indicates failure for a Boolean type. Casting an `HRESULT` to a Boolean type and then using it in a test expression will yield an incorrect result. Sometimes, this warning occurs if an `HRESULT` is being stored in a Boolean variable. Any comparison that uses the Boolean variable to test for `HRESULT` success or failure could lead to incorrect results.
+This warning indicates that an `HRESULT` is being cast to a Boolean type. The success value (`S_OK`) of an `HRESULT` equals 0. However, 0 indicates failure for a Boolean type. Casting an `HRESULT` to a Boolean type and then using it in a test expression will yield an incorrect result.
+
+## Remarks
+
+Sometimes, this warning occurs if an `HRESULT` is being stored in a Boolean variable. Any comparison that uses the Boolean variable to test for `HRESULT` success or failure could lead to incorrect results.
+
+Code analysis name: `CAST_HRESULT_TO_BOOL`
 
 ## Example
 
-The following code generates this warning:
+The following code generates warning C6214:
 
 ```cpp
 #include <windows.h>
@@ -66,10 +72,10 @@ For this warning, the `SCODE` type is equivalent to `HRESULT`.
 
 Usually, the `SUCCEEDED` or `FAILED` macro should be used to test the value of an `HRESULT`.
 
-For more information, see one of the following topics:
+For more information, see one of the following articles:
 
-[SUCCEEDED](/windows/desktop/api/winerror/nf-winerror-succeeded)
+[`SUCCEEDED`](/windows/desktop/api/winerror/nf-winerror-succeeded)
 
-[FAILED](/windows/desktop/api/winerror/nf-winerror-failed)
+[`FAILED`](/windows/desktop/api/winerror/nf-winerror-failed)
 
-To leverage modern C++ memory allocation methodology, 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).
+To make use of modern C++ memory allocation methodology, use the mechanisms that are provided by the C++ Standard Library (STL). These include [`shared_ptr`](../standard-library/shared-ptr-class.md), [`unique_ptr`](../standard-library/unique-ptr-class.md), and containers such as [`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).