Merging changes synced from https://github.com/MicrosoftDocs/cpp-docs-pr (branch live)

Author: opbld15

docs/code-quality/c26800.md

@@ -10,7 +10,7 @@ ms.author: sunnych
 ---
 # C26800
 
-> warning C26800: Use of a moved from object: \<lock>.
+> warning C26800: Use of a moved from object: \<object>.
 
 Warning C26800 is triggered when variable is used after it has been moved from. A variable is considered moved from after it was passed to a function as rvalue reference. There are some legitimate exceptions for uses such as assignment, destruction, and some state resetting functions such as std::vector::clear.
 

docs/code-quality/c26822.md

@@ -0,0 +1,42 @@
+---
+title: C26822
+description: "Describes the Microsoft C/C++ code analysis warning C26822, its causes, and how to address it."
+ms.date: 06/27/2022
+f1_keywords: ["C26822"]
+helpviewer_keywords: ["C26822"]
+---
+
+# C26822: NULLPTR_DEREFERENCE
+
+Dereferencing a null pointer is frequent problem in C and C++. We have a variety of checks to deal with such problems. See this [blog post](https://devblogs.microsoft.com/cppblog/improved-null-pointer-dereference-detection-in-visual-studio-2022-version-17-0-preview-4/) for a comparison. When the analysis engine deduces the value of a pointer to be null and sees a dereference to that pointer it will emit a  `C26822` warning. You can also enable [C26823](../code-quality/c26823.md) for a stricter analysis. This check also supports [SAL annotations](../code-quality/understanding-sal.md) and [`gsl::not_null`](https://github.com/microsoft/GSL) to describe invariants of the code.
+
+
+## Example
+
+```cpp
+void f(int *p) { 
+    if (p == nullptr) 
+        *p = 42; // warning: C26822
+} 
+
+void assign_to_gsl_notnull() { 
+    int* p = nullptr; 
+    auto q = gsl::make_not_null(p); // C26822 warning 
+} 
+```
+
+To solve this warning, make sure there is no null pointer dereference in the code, potentially by adding null checks. In case the code was found to be correct, false positive findings can often be fixed by using `gsl::not_null` or SAL annotations. There are some examples how to use some of those annotations below:
+
+```cpp
+_Notnull_ int *get_my_ptr(); 
+gsl::not_null<int *> get_my_ptr2(); 
+
+void local_analysis(int *p) { 
+    _Analysis_assume_(p != nullptr); 
+    *p = 42; 
+} 
+
+void local_analysis2(_In_ int *p) { 
+    int a = *p; 
+} 
+```

docs/code-quality/c26823.md

@@ -0,0 +1,43 @@
+---
+title: C26823
+description: "Describes the Microsoft C/C++ code analysis warning C26823, its causes, and how to address it."
+ms.date: 06/27/2022
+f1_keywords: ["C26823"]
+helpviewer_keywords: ["C26823"]
+---
+
+# C26823: NULLPTR_DEREFERENCE_MAYBE
+
+Dereferencing a null pointer is frequent problem in C and C++. We have a variety of checks to deal with such problems. See this [blog post](https://devblogs.microsoft.com/cppblog/improved-null-pointer-dereference-detection-in-visual-studio-2022-version-17-0-preview-4/) for a comparison. When the analysis engine deduces the value of a pointer might be null and sees a dereference to that pointer it will emit a  `C26823` warning. You can enable [C26822](../code-quality/c26822.md) only for a more permissive analysis. This check also supports [SAL annotations](../code-quality/understanding-sal.md) and [`gsl::not_null`](https://github.com/microsoft/GSL) to describe invariants of the code.
+
+
+## Example
+
+```cpp
+void invalidate(int **pp);
+void condition_null_dereference_invalidated(int* p)
+{
+    if (p)
+        return;
+
+    invalidate(&p);
+    // The call above could reset the value of `p`, thus the low confidence warning.
+    *p = 5; // warning: C26823
+}
+```
+
+To solve this warning, make sure there is no null pointer dereference in the code, potentially by adding null checks. In case the code was found to be correct, false positive findings can often be fixed by using `gsl::not_null` or SAL annotations. There are some examples how to use some of those annotations below:
+
+```cpp
+_Notnull_ int *get_my_ptr(); 
+gsl::not_null<int *> get_my_ptr2(); 
+
+void local_analysis(int *p) { 
+    _Analysis_assume_(p != nullptr); 
+    *p = 42; 
+} 
+
+void local_analysis2(_In_ int *p) { 
+    int a = *p; 
+} 
+```

docs/code-quality/c26824.md

@@ -0,0 +1,23 @@
+---
+title: C26824
+description: "Describes the Microsoft C/C++ code analysis warning C26824, its causes, and how to address it."
+ms.date: 06/27/2022
+f1_keywords: ["C26824"]
+helpviewer_keywords: ["C26824"]
+---
+
+# C26824: NULLPTR_POSTCONDITION_VIOLATION
+
+Dereferencing a null pointer is frequent problem in C and C++. We have a variety of checks to deal with such problems. See this [blog post](https://devblogs.microsoft.com/cppblog/improved-null-pointer-dereference-detection-in-visual-studio-2022-version-17-0-preview-4/) for a comparison. When the analysis engine sees a null pointer returned from a function that has a contract forbidding such operation, it will emit a `C26824` warning. You can also enable [C26825](../code-quality/c26825.md) for a stricter analysis. This check only works on functions annotated using [SAL annotations](../code-quality/understanding-sal.md).
+
+
+## Example
+
+```cpp
+void postcondition_conditional(bool b, _When_(b == true, _Outptr_) int** p)  { 
+    if (b == true) 
+        *p = nullptr; // C26824 warning 
+} 
+```
+
+To solve this warning, make sure there is no null pointer returned from the annotated function or change the annotations to reflect the behavior of the function.

docs/code-quality/c26825.md

@@ -0,0 +1,22 @@
+---
+title: C26825
+description: "Describes the Microsoft C/C++ code analysis warning C26825, its causes, and how to address it."
+ms.date: 06/27/2022
+f1_keywords: ["C26825"]
+helpviewer_keywords: ["C26825"]
+---
+
+# C26825: NULLPTR_POSTCONDITION_VIOLATION_MAYBE
+
+Dereferencing a null pointer is frequent problem in C and C++. We have a variety of checks to deal with such problems. See this [blog post](https://devblogs.microsoft.com/cppblog/improved-null-pointer-dereference-detection-in-visual-studio-2022-version-17-0-preview-4/) for a comparison. When the analysis engine sees a potentially null pointer returned from a function that has a contract forbidding such operation, it will emit a `C26825` warning. You can enable [C26824](../code-quality/c26824.md) only for a more permissive analysis. This check only works on functions annotated using [SAL annotations](../code-quality/understanding-sal.md).
+
+
+## Example
+
+```cpp
+void postcondition_conditional(int *q, _Outptr_ int** p)  { 
+    *p = q; // C26825 warning 
+} 
+```
+
+To solve this warning, make sure there is no null pointer returned from the annotated function or change the annotations to reflect the behavior of the function.

docs/code-quality/toc.yml

@@ -583,6 +583,14 @@ items:
     href: ../code-quality/c26811.md
   - name: C26813
     href: ../code-quality/c26813.md
+  - name: C26822
+    href: ../code-quality/c26822.md
+  - name: C26823
+    href: ../code-quality/c26823.md
+  - name: C26824
+    href: ../code-quality/c26824.md
+  - name: C26825
+    href: ../code-quality/c26825.md
   - name: C26826
     href: ../code-quality/c26826.md
   - name: C26827