Merge pull request MicrosoftDocs#3045 from MicrosoftDocs/FromPublicMasterBranch

Confirm merge from FromPublicMasterBranch to master to sync with https://github.com/MicrosoftDocs/cpp-docs (branch master)

Author: Colin Robertson

docs/code-quality/c26474.md

@@ -1,38 +1,41 @@
 ---
 title: C26474
-ms.date: 11/15/2017
+ms.date: 08/11/2020
 ms.topic: "conceptual"
 f1_keywords: ["C26474"]
 helpviewer_keywords: ["C26474"]
 ms.assetid: 1e23a8e6-97fa-47f5-a279-b52aa2efafa4
-
 ---
 # C26474 NO_IMPLICIT_CAST
 
 "Don't cast between pointer types when the conversion could be implicit."
 
-**C++ Core Guidelines**:
+**C++ Core Guidelines**:\
 Type.1: Avoid casts
 
-In some cases, implicit casts between pointer types can safely be done and don’t require user to write specific cast expression. This rule finds instances of such unnecessary casting which can be removed.
+In some cases, implicit casts between pointer types are safe and don't require you to write a specific cast expression. This rule finds instances of unnecessary casts you can safely remove.
 
 ## Remarks
 
-- The rule ID is a bit misleading: it should be interpreted as "implicit cast is not used where it is acceptable".
-  - The rule is applicable to pointers only and checks static casts and reinterpret casts.
-  - The following cases are acceptable pointer conversions that should not use explicit cast expressions:
-  - conversion to nullptr_t;
-  - conversion to void*;
-  - conversion from derived type to its base.
+The rule ID should be interpreted as "An implicit cast isn't used where it's acceptable."
+
+This rule is only applicable to pointers. It checks static casts and reinterpret casts.
+
+These cases are acceptable pointer conversions that shouldn't use explicit cast expressions:
+- conversion to `nullptr_t`;
+- conversion to `void*`;
+- conversion from a derived type to its base when invoking a base member function that's not hidden by the derived type. 
 
-## Example
+## Example 1
 
-unnecessary conversion hides logic error
+An unnecessary conversion hides a logic error in this example:
 
 ```cpp
 template<class T>
 bool register_buffer(T buffer) {
     auto p = reinterpret_cast<void*>(buffer); // C26474, also 26490 NO_REINTERPRET_CAST
+    // To fix, declare buffer as T*, and use this to define p:
+    // auto p = buffer;
     return buffers_.insert(p).second;
 }
 
@@ -47,14 +50,26 @@ void merge_bytes(std::uint8_t *left, std::uint8_t *right)
 }
 ```
 
-unnecessary conversion hides logic error - reworked
+## Example 2
+
+This example demonstrates using casts to access base-class member functions:
 
 ```cpp
-// ...
-template<class T>
-bool register_buffer(T *buffer) {
-    auto p = buffer;
-    return buffers_.insert(p).second;
+struct struct_1
+{
+    void foo();
+    void bar();
+};
+
+struct struct_2 : struct_1
+{
+    void foo(); // this definition hides struct_1::foo
+};
+
+void fn(struct_2* ps2)
+{
+    static_cast<struct_1*>(ps2)->foo(); // This cast is necessary to access struct_1::foo
+                                        // Alternatively, use ps2->struct_1::foo();
+    static_cast<struct_1*>(ps2)->bar(); // This cast is unnecessary and can be done implicitly
 }
-// ...
 ```