Prepare for new ptr-to-member error (MicrosoftDocs#3503)

Author: Colin Robertson

docs/build/reference/vmb-vmg-representation-method.md

@@ -1,45 +1,42 @@
 ---
-description: "Learn more about: /vmb, /vmg (Representation Method)"
+description: "Learn more about: /vmb, /vmg (Representation method)"
 title: "/vmb, /vmg (Representation Method)"
-ms.date: "11/04/2016"
+ms.date: 04/12/2021
 f1_keywords: ["/vmb", "/vmg"]
 helpviewer_keywords: ["vmb compiler option [C++]", "-vmg compiler option [C++]", "vmg compiler option [C++]", "-vmb compiler option [C++]", "/vmb compiler option [C++]", "representation method compiler options [C++]", "/vmg compiler option [C++]"]
-ms.assetid: ecdb391c-7dab-40b1-916b-673d10889fd4
 ---
-# /vmb, /vmg (Representation Method)
+# `/vmb`, `/vmg` (Representation method)
 
 Select the method that the compiler uses to represent pointers to class members.
 
-Use **/vmb** if you always define a class before you declare a pointer to a member of the class.
+## Syntax
 
-Use **/vmg** to declare a pointer to a member of a class before defining the class. This need can arise if you define members in two different classes that reference each other. For such mutually referencing classes, one class must be referenced before it is defined.
+> **`/vmb`**\
+> **`/vmg`**
 
-## Syntax
+### Options
 
-```
-/vmb
-/vmg
-```
+**`/vmb`** is the compiler's default behavior. Its behavior is the same as `#pragma pointers_to_members(best_case)`. It doesn't require or ensure complete types. For complete types, it uses the best representation among single, multiple, or virtual inheritance based the inheritance of the class type. For incomplete types, it uses the largest, most general representation.
+
+**`/vmg`** lets you specify compiler behavior in combination with [`/vmm`, `/vms`, `/vmv` (General purpose representation)](./vmm-vms-vmv-general-purpose-representation.md) to declare a pointer to a member of a class before defining the class. This need can arise if you define members in two different classes that reference each other. For such mutually referencing classes, one class must be referenced before it's defined.
 
 ## Remarks
 
-You can also use [pointers_to_members](../../preprocessor/pointers-to-members.md) or [Inheritance Keywords](../../cpp/inheritance-keywords.md) in your code to specify a pointer representation.
+You can also use [`#pragma pointers_to_members`](../../preprocessor/pointers-to-members.md) or [Inheritance keywords](../../cpp/inheritance-keywords.md) in your code to specify a pointer representation.
 
 ### To set this compiler option in the Visual Studio development environment
 
 1. Open the project's **Property Pages** dialog box. For details, see [Set C++ compiler and build properties in Visual Studio](../working-with-project-properties.md).
 
-1. Click the **C/C++** folder.
-
-1. Click the **Command Line** property page.
+1. Select the **Configuration Properties** > **C/C++** > **Command Line** property page.
 
-1. Type the compiler option in the **Additional Options** box.
+1. Enter the compiler option in the **Additional Options** box.
 
 ### To set this compiler option programmatically
 
 - See <xref:Microsoft.VisualStudio.VCProjectEngine.VCCLCompilerTool.AdditionalOptions%2A>.
 
 ## See also
 
-[MSVC Compiler Options](compiler-options.md)<br/>
-[MSVC Compiler Command-Line Syntax](compiler-command-line-syntax.md)
+[MSVC compiler options](compiler-options.md)<br/>
+[MSVC compiler command-line syntax](compiler-command-line-syntax.md)

docs/build/reference/vmm-vms-vmv-general-purpose-representation.md

@@ -1,51 +1,66 @@
 ---
 description: "Learn more about: /vmm, /vms, /vmv (General Purpose Representation)"
-title: "/vmm, -vms, -vmv (General Purpose Representation)"
-ms.date: "11/04/2016"
+title: "/vmm, /vms, /vmv (General Purpose Representation)"
+ms.date: 04/12/2021
 f1_keywords: ["/vms", "/vmm", "/vmv"]
 helpviewer_keywords: ["Virtual Inheritance compiler option", "general purpose representation compiler options", "vms compiler option [C++]", "vmm compiler option [C++]", "/vmm compiler option [C++]", "-vmm compiler option [C++]", "-vms compiler option [C++]", "/vms compiler option [C++]", "vmv compiler option [C++]", "/vmv compiler option [C++]", "Single Inheritance compiler option", "-vmv compiler option [C++]"]
-ms.assetid: 0fcd7ae0-3031-4c62-a2a8-e154c8685dae
 ---
-# /vmm, /vms, /vmv (General Purpose Representation)
+# `/vmm`, `/vms`, `/vmv` (General Purpose Representation)
 
-Used when [/vmb, /vmg (Representation Method)](vmb-vmg-representation-method.md) is selected as the [representation method](vmb-vmg-representation-method.md). These options indicate the inheritance model of the not-yet-encountered class definition.
+Used when [`/vmg`](vmb-vmg-representation-method.md) is selected as the [representation method](vmb-vmg-representation-method.md). These options indicate the inheritance model of the not-yet-encountered class definition.
 
 ## Syntax
 
-```
-/vmm
-/vms
-/vmv
-```
+> **`/vmm`**\
+> **`/vms`**\
+> **`/vmv`**
 
-## Remarks
+### Options
+
+**`/vmm`**\
+Specifies the most general representation of a pointer to a member of a class as one that uses multiple inheritance.
+
+The corresponding [inheritance keyword](../../cpp/inheritance-keywords.md) and argument to [`#pragma pointers_to_members`](../../preprocessor/pointers-to-members.md) is **`multiple_inheritance`**.
+
+This representation is larger than the one required for single inheritance.
+
+If you use **`/vmm`** and declare a pointer to member of a class that has a virtual inheritance model, the compiler generates an error.
+
+**`/vms`**\
+Specifies the most general representation of a pointer to a member of a class as one that uses either no inheritance or single inheritance.The corresponding [inheritance keyword](../../cpp/inheritance-keywords.md) and argument to [`#pragma pointers_to_members`](../../preprocessor/pointers-to-members.md) is **`single_inheritance`**.
 
-The options are described in the following table.
+This option generates the smallest possible representation of a pointer to a member of a class.
+
+If you use **`/vms`** and declare a pointer to member of a class that has a multiple or virtual inheritance model, the compiler generates an error.
+
+**`/vmv`**\
+Specifies the most general representation of a pointer to a member of a class as one that uses virtual inheritance. This pointer representation never causes an error and is the default.
+
+The corresponding [inheritance keyword](../../cpp/inheritance-keywords.md) and argument to [`#pragma pointers_to_members`](../../preprocessor/pointers-to-members.md) is **`virtual_inheritance`**.
+
+This option requires a larger pointer and more code to interpret the pointer than the other options.
+
+## Remarks
 
-|Option|Description|
-|------------|-----------------|
-|**/vmm**|Specifies the most general representation of a pointer to a member of a class to be one that uses multiple inheritance.<br /><br /> The corresponding [inheritance keyword](../../cpp/inheritance-keywords.md) and argument to [#pragma pointers_to_members](../../preprocessor/pointers-to-members.md) is **multiple_inheritance**.<br /><br /> This representation is larger than that required for single inheritance.<br /><br /> If the inheritance model of a class definition for which a pointer to a member is declared is virtual, the compiler generates an error.|
-|**/vms**|Specifies the most general representation of a pointer to a member of a class to be one that uses either no inheritance or single inheritance.<br /><br /> The corresponding [inheritance keyword](../../cpp/inheritance-keywords.md) and argument to [#pragma pointers_to_members](../../preprocessor/pointers-to-members.md) is **single_inheritance**.<br /><br /> This is the smallest possible representation of a pointer to a member of a class.<br /><br /> If the inheritance model of a class definition for which a pointer to a member is declared is multiple or virtual, the compiler generates an error.|
-|**/vmv**|Specifies the most general representation of a pointer to a member of a class to be one that uses virtual inheritance. It never causes an error and is the default.<br /><br /> The corresponding [inheritance keyword](../../cpp/inheritance-keywords.md) and argument to [#pragma pointers_to_members](../../preprocessor/pointers-to-members.md) is **virtual_inheritance**.<br /><br /> This option requires a larger pointer and additional code to interpret the pointer than the other options.|
+In Visual Studio 2019 and earlier versions, Microsoft uses different representations (of different sizes) for pointer-to-member types. Pointers to members of classes that have no inheritance or single inheritance have the smallest representation. Pointers to members of classes that have multiple inheritance are larger. Pointers to members of classes that have virtual inheritance are the largest. When no representation model is specified to the compiler, it defaults to using the largest, most general representation.
 
-When you specify one of these inheritance-model options, that model is used for all pointers to class members, regardless of their inheritance type or whether the pointer is declared before or after the class. Therefore, if you always use single-inheritance classes, you can reduce code size by compiling with **/vms**; however, if you want to use the most general case (at the expense of the largest data representation), compile with **/vmv**.
+When you specify one of these inheritance-model options, that model gets used for all pointers to class members, no matter their inheritance type or whether you declare the pointer before or after the class. If you always use single-inheritance classes, you can reduce code size by compiling with **`/vms`**. However, if you want to use the most general case (at the expense of the largest data representation), compile with **`/vmv`**.
 
 ### To set this compiler option in the Visual Studio development environment
 
 1. Open the project's **Property Pages** dialog box. For details, see [Set C++ compiler and build properties in Visual Studio](../working-with-project-properties.md).
 
-1. Click the **C/C++** folder.
+1. Select the **Configuration Properties** > **C/C++** > **Command Line** property page.
 
-1. Click the **Command Line** property page.
+1. Enter the compiler option in the **Additional Options** box.
 
-1. Type the compiler option in the **Additional Options** box.
 
 ### To set this compiler option programmatically
 
 - See <xref:Microsoft.VisualStudio.VCProjectEngine.VCCLCompilerTool.AdditionalOptions%2A>.
 
 ## See also
 
-[/vmb, /vmg (Representation Method)](vmb-vmg-representation-method.md)<br/>
-[MSVC Compiler Options](compiler-options.md)<br/>
-[MSVC Compiler Command-Line Syntax](compiler-command-line-syntax.md)
+[`/vmb`, `/vmg` (Representation method)](vmb-vmg-representation-method.md)<br/>
+[MSVC compiler options](compiler-options.md)<br/>
+[MSVC compiler command-line syntax](compiler-command-line-syntax.md)

docs/cpp/inheritance-keywords.md

@@ -1,47 +1,43 @@
 ---
 description: "Learn more about: Inheritance Keywords"
-title: "Inheritance Keywords"
-ms.date: "11/04/2016"
+title: "Inheritance keywords"
+ms.date: 04/12/2021
 f1_keywords: ["__multiple_inheritance", "__single_inheritance_cpp", "__virtual_inheritance_cpp", "__virtual_inheritance", "__multiple_inheritance_cpp", "__single_inheritance"]
 helpviewer_keywords: ["__single_inheritance keyword [C++]", "declaring derived classes [C++]", "keywords [C++], inheritance keywords", "__multiple_inheritance keyword [C++]", "__virtual_inheritance keyword [C++]", "inheritance, declaring derived classes", "derived classes [C++], declaring", "inheritance, keywords"]
-ms.assetid: bb810f56-7720-4fea-b8b6-9499edd141df
 ---
-# Inheritance Keywords
+# Inheritance keywords
 
 **Microsoft Specific**
 
-```
-class [__single_inheritance] class-name;
-class [__multiple_inheritance] class-name;
-class [__virtual_inheritance] class-name;
-```
+> **`class`** *`class-name`*\
+> **`class __single_inheritance`** *`class-name`*\
+> **`class __multiple_inheritance`** *`class-name`*\
+> **`class __virtual_inheritance`** *`class-name`*
 
 where:
 
-*class-name*<br/>
+*`class-name`*<br/>
 The name of the class being declared.
 
-C++ allows you to declare a pointer to a class member prior to the definition of the class. For example:
+C++ allows you to declare a pointer to a class member before the definition of the class. For example:
 
 ```cpp
 class S;
 int S::*p;
 ```
 
-In the code above, `p` is declared to be a pointer to integer member of class S. However, `class S` has not yet been defined in this code; it has only been declared. When the compiler encounters such a pointer, it must make a generalized representation of the pointer. The size of the representation is dependent on the inheritance model specified. There are four ways to specify an inheritance model to the compiler:
-
-- In the IDE under **Pointer-to-member representation**
+In the code above, `p` is declared to be a pointer to integer member of class S. However, `class S` hasn't been defined yet in this code; it's only been declared. When the compiler encounters such a pointer, it must make a generalized representation of the pointer. The size of the representation is dependent on the inheritance model specified. There are three ways to specify an inheritance model to the compiler:
 
-- At the command line using the [/vmg](../build/reference/vmb-vmg-representation-method.md) switch
+- At the command line using the [`/vmg`](../build/reference/vmb-vmg-representation-method.md) switch
 
-- Using the [pointers_to_members](../preprocessor/pointers-to-members.md) pragma
+- Using the [`pointers_to_members`](../preprocessor/pointers-to-members.md) pragma
 
 - Using the inheritance keywords **`__single_inheritance`**, **`__multiple_inheritance`**, and **`__virtual_inheritance`**. This technique controls the inheritance model on a per-class basis.
 
     > [!NOTE]
     >  If you always declare a pointer to a member of a class after defining the class, you don't need to use any of these options.
 
-Declaring a pointer to a member of a class prior to the class definition affects the size and speed of the resulting executable file. The more complex the inheritance used by a class, the greater the number of bytes required to represent a pointer to a member of the class and the larger the code required to interpret the pointer. Single inheritance is least complex, and virtual inheritance is most complex.
+If you declare a pointer to a class member before the class is defined, it can negatively affect the size and speed of the resulting executable file. The more complex the inheritance used by a class, the greater the number of bytes required to represent a pointer to a member of the class. And, the larger the code required to interpret the pointer. Single (or no) inheritance is least complex, and virtual inheritance is most complex. Pointers to members you declare before the class is defined always use the largest, most complex representation.
 
 If the example above is changed to:
 
@@ -50,12 +46,12 @@ class __single_inheritance S;
 int S::*p;
 ```
 
-regardless of command-line options or pragmas, pointers to members of `class S` will use the smallest possible representation.
+then no matter the command-line options or pragmas you specify, pointers to members of `class S` will use the smallest possible representation.
 
 > [!NOTE]
 > The same forward declaration of a class pointer-to-member representation should occur in every translation unit that declares pointers to members of that class, and the declaration should occur before the pointers to members are declared.
 
-For compatibility with previous versions, **`_single_inheritance`**, **`_multiple_inheritance`**, and **`_virtual_inheritance`** are synonyms for **`__single_inheritance`**, **`__multiple_inheritance`**, and **`__virtual_inheritance`** unless compiler option [/Za \(Disable language extensions)](../build/reference/za-ze-disable-language-extensions.md) is specified.
+For compatibility with previous versions, **`_single_inheritance`**, **`_multiple_inheritance`**, and **`_virtual_inheritance`** are synonyms for **`__single_inheritance`**, **`__multiple_inheritance`**, and **`__virtual_inheritance`** unless compiler option [`/Za` \(Disable language extensions)](../build/reference/za-ze-disable-language-extensions.md) is specified.
 
 **END Microsoft Specific**
 

docs/error-messages/compiler-warnings/compiler-warning-level-1-c4407.md

@@ -1,22 +1,25 @@
 ---
 description: "Learn more about: Compiler Warning (level 1) C4407"
 title: "Compiler Warning (level 1) C4407"
-ms.date: "11/04/2016"
+ms.date: 04/13/2021
 f1_keywords: ["C4407"]
 helpviewer_keywords: ["C4407"]
-ms.assetid: 32bc2c21-363a-4bb8-b486-725faeaededc
 ---
 # Compiler Warning (level 1) C4407
 
-cast between different pointer to member representations, compiler may generate incorrect code
+> cast between different pointer to member representations, compiler may generate incorrect code
 
-An incorrect cast was detected.
+An incorrect cast between pointer-to-member types was detected.
+
+## Remarks
 
 C4407 can be generated because of compiler conformance work that was done in Visual Studio 2005. Pointer-to-member now requires a qualified name and the address-of operator (&).
 
-C4407 can occur if you cast between a multiple inheritance pointer-to-member to a single inheritance pointer-to-member. Sometimes this can work, but sometimes it can’t because the single inheritance pointer-to-member representation doesn’t hold sufficient information. Compiling with the **/vmm** might help (for more information, see [/vmm, /vms, /vmv (General Purpose Representation)](../../build/reference/vmm-vms-vmv-general-purpose-representation.md)). You can also try rearranging your base classes; the compiler is detecting a loss of information in the conversion because a base class is at a non-zero offset from the derived.
+C4407 can occur if you cast between a multiple inheritance pointer-to-member to a single inheritance pointer-to-member. Sometimes this can work, but sometimes it can’t because the single inheritance pointer-to-member representation doesn’t hold sufficient information. Compiling with the **`/vmm`** might help. For more information, see [`/vmm`, `/vms`, `/vmv` (General purpose representation)](../../build/reference/vmm-vms-vmv-general-purpose-representation.md). You can also try rearranging your base classes; the compiler is detecting a loss of information in the conversion because a base class is at a non-zero offset from the derived.
+
+## Example
 
-The following sample generates C4407:
+The following sample generates C4407 and shows how to fix it:
 
 ```cpp
 // C4407.cpp