format cpp pr4

Author: mtx48109

docs/cpp/dllexport-dllimport.md

@@ -15,7 +15,7 @@ ms.workload: ["cplusplus"]
 # dllexport, dllimport
 **Microsoft Specific**  
 
- The `dllexport` and **dllimport** storage-class attributes are Microsoft-specific extensions to the C and C++ languages. You can use them to export and import functions, data, and objects to or from a DLL.  
+ The **dllexport** and **dllimport** storage-class attributes are Microsoft-specific extensions to the C and C++ languages. You can use them to export and import functions, data, and objects to or from a DLL.  
 
 ## Syntax  
 
@@ -26,15 +26,15 @@ ms.workload: ["cplusplus"]
 ```  
 
 ## Remarks  
- These attributes explicitly define the DLL's interface to its client, which can be the executable file or another DLL. Declaring functions as `dllexport` eliminates the need for a module-definition (.def) file, at least with respect to the specification of exported functions. The `dllexport` attribute replaces the `__export` keyword.  
+ These attributes explicitly define the DLL's interface to its client, which can be the executable file or another DLL. Declaring functions as **dllexport** eliminates the need for a module-definition (.def) file, at least with respect to the specification of exported functions. The **dllexport** attribute replaces the **__export** keyword.  
 
  If a class is marked declspec(dllexport), any specializations of class templates in the class hierarchy are implicitly marked as declspec(dllexport). This means that class templates are explicitly instantiated and the class's members must be defined.  
 
- `dllexport` of a function exposes the function with its decorated name. For C++ functions, this includes name mangling. For C functions or functions that are declared as `extern "C"`, this includes platform-specific decoration that's based on the calling convention. For information on name decoration in C/C++ code, see [Decorated Names](../build/reference/decorated-names.md). No name decoration is applied to exported C functions or C++ `extern "C"` functions using the `__cdecl` calling convention.  
+ **dllexport** of a function exposes the function with its decorated name. For C++ functions, this includes name mangling. For C functions or functions that are declared as `extern "C"`, this includes platform-specific decoration that's based on the calling convention. For information on name decoration in C/C++ code, see [Decorated Names](../build/reference/decorated-names.md). No name decoration is applied to exported C functions or C++ `extern "C"` functions using the `__cdecl` calling convention.  
 
  To export an undecorated name, you can link by using a Module Definition (.def) file that defines the undecorated name in an EXPORTS section. For more information, see [EXPORTS](../build/reference/exports.md). Another way to export an undecorated name is to use a `#pragma comment(linker, "/export:alias=decorated_name")` directive in the source code.  
 
- When you declare `dllexport` or **dllimport**, you must use [extended attribute syntax](../cpp/declspec.md) and the `__declspec` keyword.  
+ When you declare **dllexport** or **dllimport**, you must use [extended attribute syntax](../cpp/declspec.md) and the **__declspec** keyword.  
 
 ## Example  
 

docs/cpp/do-while-statement-cpp.md

@@ -24,16 +24,16 @@ while ( expression ) ;
 ```  
 
 ## Remarks  
- The test of the termination condition is made after each execution of the loop; therefore, a `do-while` loop executes one or more times, depending on the value of the termination expression. The `do-while` statement can also terminate when a [break](../cpp/break-statement-cpp.md), [goto](../cpp/goto-statement-cpp.md), or [return](../cpp/return-statement-cpp.md) statement is executed within the statement body.  
+ The test of the termination condition is made after each execution of the loop; therefore, a **do-while** loop executes one or more times, depending on the value of the termination expression. The **do-while** statement can also terminate when a [break](../cpp/break-statement-cpp.md), [goto](../cpp/goto-statement-cpp.md), or [return](../cpp/return-statement-cpp.md) statement is executed within the statement body.  
 
  The *expression* must have arithmetic or pointer type. Execution proceeds as follows:  
 
 1.  The statement body is executed.  
 
-2.  Next, *expression* is evaluated. If *expression* is false, the `do-while` statement terminates and control passes to the next statement in the program. If *expression* is true (nonzero), the process is repeated, beginning with step 1.  
+2.  Next, *expression* is evaluated. If *expression* is false, the **do-while** statement terminates and control passes to the next statement in the program. If *expression* is true (nonzero), the process is repeated, beginning with step 1.  
 
 ## Example  
- The following sample demonstrates the `do-while` statement:  
+ The following sample demonstrates the **do-while** statement:  
 
 ```cpp 
 // do_while_statement.cpp  

docs/cpp/dynamic-cast-operator.md

@@ -27,11 +27,11 @@ dynamic_cast < type-id > ( expression )
 
  See [static_cast](../cpp/static-cast-operator.md) for an explanation of the difference between static and dynamic casting conversions, and when it is appropriate to use each.  
 
- There are two breaking changes in the behavior of `dynamic_cast` in managed code:  
+ There are two breaking changes in the behavior of **dynamic_cast** in managed code:  
 
--   `dynamic_cast` to a pointer to the underlying type of a boxed enum will fail at runtime, returning 0 instead of the converted pointer.  
+-   **dynamic_cast** to a pointer to the underlying type of a boxed enum will fail at runtime, returning 0 instead of the converted pointer.  
 
--   `dynamic_cast` will no longer throw an exception when `type-id` is an interior pointer to a value type, with the cast failing at runtime.  The cast will now return the 0 pointer value instead of throwing.  
+-   **dynamic_cast** will no longer throw an exception when `type-id` is an interior pointer to a value type, with the cast failing at runtime.  The cast will now return the 0 pointer value instead of throwing.  
 
  If `type-id` is a pointer to an unambiguous accessible direct or indirect base class of `expression`, a pointer to the unique subobject of type `type-id` is the result. For example:  
 
@@ -94,9 +94,9 @@ void f() {
   
  In cases of multiple inheritance, possibilities for ambiguity are introduced. Consider the class hierarchy shown in the following figure.  
   
- For CLR types, `dynamic_cast` results in either a no-op if the conversion can be performed implicitly, or an MSIL `isinst` instruction, which performs a dynamic check and returns `nullptr` if the conversion fails.  
+ For CLR types, **dynamic_cast** results in either a no-op if the conversion can be performed implicitly, or an MSIL `isinst` instruction, which performs a dynamic check and returns **nullptr** if the conversion fails.  
   
- The following sample uses `dynamic_cast` to determine if a class is an instance of particular type:  
+ The following sample uses **dynamic_cast** to determine if a class is an instance of particular type:  
   
 ```cpp 
 // dynamic_cast_clr.cpp  
@@ -143,14 +143,14 @@ void f() {
  ![Class hierarchy that shows virtual base classes](../cpp/media/vc39012.gif "vc39012")  
 Class Hierarchy Showing 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.  
+ 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 "vc39013")  
 Class Hierarchy Showing 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:  
+ 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:  
   
 ```cpp 
 // dynamic_cast_5.cpp  
@@ -168,7 +168,7 @@ void f(D* pd) {
 }  
 ```  
 
- The `dynamic_cast` operator can also be used to perform a "cross cast." Using the same class hierarchy, it is possible to cast a pointer, for example, from the `B` subobject to the `D` subobject, as long as the complete object is of type `E`.  
+ The **dynamic_cast** operator can also be used to perform a "cross cast." Using the same class hierarchy, it is possible to cast a pointer, for example, from the `B` subobject to the `D` subobject, as long as the complete object is of type `E`.  
 
  Considering cross casts, it is actually possible to do the conversion from a pointer to `D` to a pointer to the left-most `A` subobject in just two steps. You can perform a cross cast from `D` to `B`, then an implicit conversion from `B` to `A`. For example:  
 
@@ -187,7 +187,7 @@ void f(D* pd) {
 }  
 ```  
   
- A null pointer value is converted to the null pointer value of the destination type by `dynamic_cast`.  
+ A null pointer value is converted to the null pointer value of the destination type by **dynamic_cast**.  
   
  When you use `dynamic_cast < type-id > ( expression )`, if `expression` cannot be safely converted to type `type-id`, the run-time check causes the cast to fail. For example:  
   

docs/cpp/ellipses-and-variadic-templates.md

@@ -73,7 +73,7 @@ template <typename... Arguments> returntype functionname(Arguments&&... args);
 template <typename... Arguments> returntype functionname(Arguments*... args);  
 ```  
 
- Specifiers like `const` are also allowed:  
+ Specifiers like **const** are also allowed:  
 
 ```cpp  
 template <typename... Arguments> returntype functionname(const Arguments&... args);  

docs/cpp/enumerations-cpp.md

@@ -16,7 +16,7 @@ ms.workload: ["cplusplus"]
 An enumeration is a user-defined type that consists of a set of named integral constants that are known as enumerators.  
 
 > [!NOTE]
->  This article covers the ISO Standard C++ Language `enum` type and the scoped (or strongly-typed) `enum class` type which is introduced in C++11. For information about the `public enum class` or `private enum class` types in C++/CLI and C++/CX, see [enum class](../windows/enum-class-cpp-component-extensions.md).  
+>  This article covers the ISO Standard C++ Language **enum** type and the scoped (or strongly-typed) **enum class** type which is introduced in C++11. For information about the **public enum class** or **private enum class** types in C++/CLI and C++/CX, see [enum class](../windows/enum-class-cpp-component-extensions.md).  
   
 ## Syntax  
 
@@ -39,17 +39,17 @@ enum class C : short;  // ... may have any integral underlying type
 ```  
   
 ## Parameters  
- `identifier`  
+ *identifier*  
  The type name given to the enumeration.  
   
- `type`  
+ *type*  
  The underlying type of the enumerators; all enumerators have the same underlying type. May be any integral type.  
   
- `enum-list`  
- Comma-separated list of the enumerators in the enumeration. Every enumerator or variable name in the scope must be unique. However, the values can be duplicated. In a unscoped enum, the scope is the surrounding scope; in a scoped enum, the scope is the `enum-list` itself.  In a scoped enum, the list may be empty which in effect defines a new integral type.
+ *enum-list*  
+ Comma-separated list of the enumerators in the enumeration. Every enumerator or variable name in the scope must be unique. However, the values can be duplicated. In a unscoped enum, the scope is the surrounding scope; in a scoped enum, the scope is the *enum-list* itself.  In a scoped enum, the list may be empty which in effect defines a new integral type.
   
- `class`  
- By using this keyword in the declaration, you specify the enum is scoped, and an `identifier` must be provided. You can also use the `struct` keyword in place of `class`, as they are semantically equivalent in this context.  
+ *class*  
+ By using this keyword in the declaration, you specify the enum is scoped, and an *identifier* must be provided. You can also use the **struct** keyword in place of **class**, as they are semantically equivalent in this context.  
   
 ## Enumerator scope  
  An enumeration provides context to describe a range of values which are represented as named constants and are also called enumerators. In the original C and C++ enum types, the unqualified enumerators are visible throughout the scope in which the enum is declared. In scoped enums, the enumerator name must be qualified by the enum type name. The following example demonstrates this basic difference between the two kinds of enums:  
@@ -98,7 +98,7 @@ enum Suit { Diamonds = 5, Hearts, Clubs = 4, Spades };
 
  ## Casting rules  
 
- Unscoped enum constants can be implicitly converted to `int`, but an `int` is never implicitly convertible to an enum value. The following example shows what happens if you try to assign `hand` a value that is not a `Suit`:  
+ Unscoped enum constants can be implicitly converted to **int**, but an **int** is never implicitly convertible to an enum value. The following example shows what happens if you try to assign `hand` a value that is not a `Suit`:  
 
 ```cpp  
 int account_num = 135692;  
@@ -107,7 +107,7 @@ hand = account_num; // error C2440: '=' : cannot convert from 'int' to 'Suit'
 
 ```  
 
- A cast is required to convert an `int` to a scoped or unscoped enumerator. However, you can promote a unscoped enumerator to an integer value without a cast.  
+ A cast is required to convert an **int** to a scoped or unscoped enumerator. However, you can promote a unscoped enumerator to an integer value without a cast.  
 
 ```cpp  
 int account_num = Hearts; //OK if Hearts is in a unscoped enum  

docs/cpp/equality-operators-equal-equal-and-exclpt-equal.md

@@ -23,9 +23,9 @@ expression != expression
 ## Remarks  
  The binary equality operators compare their operands for strict equality or inequality.  
 
- The equality operators, equal to (`==`) and not equal to (`!=`), have lower precedence than the relational operators, but they behave similarly. The result type for these operators is `bool`.  
+ The equality operators, equal to (`==`) and not equal to (`!=`), have lower precedence than the relational operators, but they behave similarly. The result type for these operators is **bool**.  
 
- The equal-to operator (`==`) returns **true** (1) if both operands have the same value; otherwise, it returns **false** (0). The not-equal-to operator (`!=`) returns **true** if the operands do not have the same value; otherwise, it returns **false**.  
+ The equal-to operator (`==`) returns TRUE (1) if both operands have the same value; otherwise, it returns FALSE (0). The not-equal-to operator (`!=`) returns TRUE if the operands do not have the same value; otherwise, it returns FALSE.  
 
 ## Operator Keyword for !=  
  The `not_eq` operator is the text equivalent of `!=`. There are two ways to access the `not_eq` operator in your programs: include the header file `iso646.h`, or compile with the [/Za](../build/reference/za-ze-disable-language-extensions.md) (Disable language extensions) compiler option.