@@ -3,7 +3,6 @@ description: "Learn more about: C++ Bit Fields"
 title: "C++ Bit Fields"
 ms.date: "11/19/2018"
 helpviewer_keywords: ["bitfields [C++]", "fields [C++], bit", "bit fields"]
-ms.assetid: 6f4b62e3-cc1d-4e5d-bf34-05904104f71a
 ---
 # C++ Bit Fields
 
@@ -35,8 +34,9 @@ struct Date {
 
 The conceptual memory layout of an object of type `Date` is shown in the following figure.
 
-![Memory layout of a date object, showing the nWeekDay, nMonthDay, nMonth, and nYear bit fields.](../cpp/media/vc38uq1.png "Memory layout of a date object") <br/>
-Memory Layout of Date Object
+:::image type="complex" source="../cpp/media/vc38uq1.png" alt-text="Memory layout of a date object, showing where the nWeekDay, nMonthDay, nMonth, and nYear bit fields fall.":::
+32 bits of memory are displayed in a row. The rightmost 3 bits are for nWeekDay. The next 6 bits to the left are for nMonthDay. The next 5 bits to the left are for nMonth. The next two bits are unused. The next 8 bits are for nYear. The remaining 8 bits to the left are unused.
+:::image-end:::  
 
 Note that `nYear` is 8 bits long and would overflow the word boundary of the declared type, **`unsigned short`**. Therefore, it is begun at the beginning of a new **`unsigned short`**. It is not necessary that all bit fields fit in one object of the underlying type; new units of storage are allocated, according to the number of bits requested in the declaration.
 
@@ -62,8 +62,9 @@ struct Date {
 
 then the memory layout is as shown in the following figure:
 
-![Layout of a Date object with a zero length bit field, which forces alignment padding.](../cpp/media/vc38uq2.png) <br/>
-Layout of Date Object with Zero-Length Bit Field
+:::image type="complex" source="../cpp/media/vc38uq2.png" alt-text="Layout of a Date object with a zero length bit field, which forces alignment padding.":::
+64 bits of memory are displayed in a row. The rightmost 5 bits are for nMonth. The next 8 bits to the left are for nYear. The next 19 bits to the left are unused. The next 3 bits to the left are for nWeekDay. The next 6 bits to the left are for nMonthDay. The remaining bits to the left are unused.
+:::image-end:::  
 
 The underlying type of a bit field must be an integral type, as described in [Built-in types](../cpp/fundamental-types-cpp.md).
 
 
@@ -4,7 +4,6 @@ description: "Overview of the C++ language dynamic_cast operator."
 ms.date: "02/03/2020"
 f1_keywords: ["dynamic_cast_cpp"]
 helpviewer_keywords: ["dynamic_cast keyword [C++]"]
-ms.assetid: f380ada8-6a18-4547-93c9-63407f19856b
 ---
 # dynamic_cast Operator
 
@@ -114,8 +113,9 @@ int main() {
 }
 ```
 
-![Class hierarchy that shows multiple inheritance.](../cpp/media/vc39011.gif "Class hierarchy that shows multiple inheritance") <br/>
-Class hierarchy that shows multiple inheritance
+:::image type="complex" source="../cpp/media/vc39011.gif" alt-text="Class hierarchy that shows multiple inheritance.":::
+The diagram shows a class hierarchy with A as a base class of B which in turn is a base class of D. A is also a base class for C which in turn is a base class for D. Note that class D inherits from both B and C.
+:::image-end:::  
 
 A pointer to an object of type `D` can be safely cast to `B` or `C`. However, if `D` is cast to point to an `A` object, which instance of `A` would result? This would result in an ambiguous casting error. To get around this problem, you can perform two unambiguous casts. For example:
 
@@ -137,14 +137,18 @@ void f() {
 
 Further ambiguities can be introduced when you use virtual base classes. Consider the class hierarchy shown in the following figure.
 
-![Class hierarchy that shows virtual base classes.](../cpp/media/vc39012.gif "Class hierarchy that shows virtual base classes") <br/>
+:::image type="complex" source="../cpp/media/vc39012.gif" alt-text="Class hierarchy that shows virtual base classes.":::
+The diagram shows the classes A, B, C, D, and E arranged as follows: Class A is a base class of B. Classes C and E each derive from B. Class E also inherits from D which inherits from class B which in turn inherits from class A.
+:::image-end:::  
 Class hierarchy that shows virtual base classes
 
 In this hierarchy, `A` is a virtual base class. Given an instance of class `E` and a pointer to the `A` subobject, a **`dynamic_cast`** to a pointer to `B` will fail due to ambiguity. You must first cast back to the complete `E` object, then work your way back up the hierarchy, in an unambiguous manner, to reach the correct `B` object.
 
 Consider the class hierarchy shown in the following figure.
 
-![Class hierarchy that shows duplicate base classes.](../cpp/media/vc39013.gif "Class hierarchy that shows duplicate base classes") <br/>
+:::image type="complex" source="../cpp/media/vc39013.gif" alt-text="Class hierarchy that shows duplicate base classes.":::
+The diagram shows the classes A, B, C, D, and E arranged as follows: Class B derives from Class A. Class C derives from class A. class D derives from class B. Class E derives from class C which derives from class A. In this case, the duplicate base class is class A which is directly or indirectly inherited by all the other classes. Class A is inherited directly by classes B and C, and indirectly by class D via class B, and indirectly by class E via class C, and indirectly in class D via class B.
+:::image-end:::  
 Class hierarchy that shows duplicate base classes
 
 Given an object of type `E` and a pointer to the `D` subobject, to navigate from the `D` subobject to the left-most `A` subobject, three conversions can be made. You can perform a **`dynamic_cast`** conversion from the `D` pointer to an `E` pointer, then a conversion (either **`dynamic_cast`** or an implicit conversion) from `E` to `B`, and finally an implicit conversion from `B` to `A`. For example:
 
@@ -4,7 +4,6 @@ title: "friend (C++)"
 ms.date: 06/30/2022
 f1_keywords: ["friend_cpp"]
 helpviewer_keywords: ["member access, from friend functions", "friend classes [C++]", "friend keyword [C++]"]
-ms.assetid: 8fe9ee55-d56f-40cd-9075-d9fb1375aff4
 ---
 # `friend` (C++)
 
@@ -225,8 +224,9 @@ Friendship isn't inherited, meaning that classes derived from `YourOtherClass` c
 
 The following figure shows four class declarations: `Base`, `Derived`, `aFriend`, and `anotherFriend`. Only class `aFriend` has direct access to the private members of `Base` (and to any members `Base` might have inherited).
 
-![Diagram showing the derivation implications of a friend relationship.](../cpp/media/vc38v41.gif "Implications of friend relationship") <br/>
-Implications of friend relationship
+::image type="complex" source="../cpp/media/vc38v41.gif" alt-text="Diagram showing the derivation implications of a friend relationship.":::
+The diagram shows that class anotherFriend doesn't have a friend relationship with class base which friends class aFriend. Class aFriend is friended by class Base, but it doesn't have a friend relationship with class Derived even though class Derived inherits from Base, thus showing that inheritance doesn't imply the derived class has the same friends as the base class.
+:::image-end:::
 
 ## Inline `friend` definitions
 
 
@@ -3,7 +3,6 @@ description: "Learn more about: Lvalues and Rvalues (C++)"
 title: "Value Categories: Lvalues and Rvalues (C++)"
 ms.date: "05/07/2019"
 helpviewer_keywords: ["R-values [C++]", "L-values [C++]"]
-ms.assetid: a8843344-cccc-40be-b701-b71f7b5cdcaf
 ---
 # Lvalues and Rvalues (C++)
 
@@ -19,7 +18,10 @@ The C++17 standard defines expression value categories as follows:
 
 The following diagram illustrates the relationships between the categories:
 
-![C++ expression value categories.](media/value_categories.png "C++ expression value categories")
+:::image type="complex" source="media/value_categories.png" alt-text="C++ expression value categories.":::
+The diagram begins with a box labeled expression, which has two children: glvalue and rvalue. glvalue has two children: lvalue and xvalue. rvalue has two children: prvalue, and it shares xvalue which is also a child of glvalue.
+:::image-end:::  
+
 
 An lvalue has an address that your program can access. Examples of lvalue expressions include variable names, including **`const`** variables, array elements, function calls that return an lvalue reference, bit-fields, unions, and class members.
 
 
@@ -230,7 +230,9 @@ In the preceding example, calling the virtual function `GetState` using a pointe
 
 In multiple-inheritance lattices involving virtual base classes, a given name can be reached through more than one path. Because different access control can be applied along these different paths, the compiler chooses the path that gives the most access. See the following figure.
 
-![Diagram showing access along the paths of an inheritance graph.](../cpp/media/vc38v91.gif "Access along paths of an inheritance graph") <br/>
+:::image type="complex" source="../cpp/media/vc38v91.gif" alt-text="Diagram showing access along the paths of an inheritance graph.":::
+The diagram shows the following inheritance hierarchy: class VBase is the base class. Class LeftPath inherits from VBase using virtual private VBase. class RightPath also inherits from VBase but using virtual public VBase. Finally, class Derived inherits from both class LeftPath and class RightPath using public LeftPath, public RightPath.
+:::image-end:::  
 Access along paths of an inheritance graph
 
 In the figure, a name declared in class `VBase` is always reached through class `RightPath`. The right path is more accessible because `RightPath` declares `VBase` as a **`public`** base class, while `LeftPath` declares `VBase` as **`private`**.
 
@@ -4,7 +4,6 @@ description: "A description of the Standard C++ union class-type and keyword, it
 ms.date: "08/18/2020"
 f1_keywords: ["union_cpp"]
 helpviewer_keywords: ["class type [C++], union as", "union keyword [C++]"]
-ms.assetid: 25c4e219-fcbb-4b7b-9b64-83f3252a92ca
 no-loc: ["union", "struct", "enum", "class", "static"]
 ---
 # `union`
@@ -536,8 +535,9 @@ int main()
 
 The `NumericType` union is arranged in memory (conceptually) as shown in the following figure.
 
-![Diagram that shows the overlapping storage of data in a numeric type union.](../cpp/media/vc38ul1.png "Storage of data in a NumericType union") <br/>
-Storage of data in a `NumericType` union
+:::image type="complex" source="../cpp/media/vc38ul1.png" alt-text="Diagram that shows the overlapping storage of data in the NumericType union.":::
+The diagram shows 8 bytes of data. The type double dValue occupies the entire 8 bytes. The type long lValue occupies the first four bytes. The type short iValue occupies the first byte.
+:::image-end:::
 
 ## <a name="anonymous_unions"></a> Anonymous union