Update C26430 rule with heuristics that was unclear in original documentation, with supporting example code snippets.

Author: Hwi-sung Im

docs/code-quality/c26430.md

@@ -27,8 +27,6 @@ A variable is marked as checked for null when it's used in the following context
 - in non-bitwise logical operations;
 - in comparison operations where one operand is a constant expression that evaluates to zero.
 
-The rule doesn't have full data flow tracking. It can produce incorrect results in cases where indirect checks are used (such as when an intermediate variable holds a null value and is later used in a comparison).
-
 Implicit null checks are assumed when a pointer value is assigned from:
 
 - an allocation performed with throwing `operator new`;
@@ -67,3 +65,32 @@ void merge_states(gsl::not_null<const state *> left, gsl::not_null<const state *
     }
 }
 ```
+
+## Heuristics
+
+The rule does not enforce every dereference of a pointer to have a prior null check to ensure the pointer is not null. Instead, it requires a null check before first derefernce of the pointer. So, the following function does not trigger a C26430 warning:
+```cpp
+void f(int* p)
+{
+    if (p)
+        *p = 1;
+    *p = 2;
+}
+```
+But the following function gets a C26430 warning because there is a path without null check for p to where *p is assigned with 2:
+```cpp
+void f(bool b, int* p)
+{
+    if (b && p)
+        *p = 1;
+    *p = 2;
+}
+```
+Rules [C26822](c26822.md) and [C26823](c26823.md) apply to dereferencing a (possibly) null pointer.  
+
+The rule doesn't have full data flow tracking. It can produce incorrect results in cases where indirect checks are used (such as when an intermediate variable holds a null value and is later used in a comparison).
+
+## See also
+
+[C26822](c26822.md)\
+[C26823](c26823.md)