format cpp pr7

Author: mtx48109

docs/cpp/postfix-increment-and-decrement-operators-increment-and-decrement.md

@@ -29,15 +29,15 @@ i++;
 
  The effect of applying the postfix increment operator (`++`) is that the operand's value is increased by one unit of the appropriate type. Similarly, the effect of applying the postfix decrement operator (**--**) is that the operand's value is decreased by one unit of the appropriate type.  
 
- It is important to note that a postfix increment or decrement expression evaluates to the value of the expression **prior to** application of the respective operator. The increment or decrement operation occurs **after** the operand is evaluated. This issue arises only when the postfix increment or decrement operation occurs in the context of a larger expression.  
+ It is important to note that a postfix increment or decrement expression evaluates to the value of the expression *prior to* application of the respective operator. The increment or decrement operation occurs *after* the operand is evaluated. This issue arises only when the postfix increment or decrement operation occurs in the context of a larger expression.  
 
  When a postfix operator is applied to a function argument, the value of the argument is not guaranteed to be incremented or decremented before it is passed to the function.  See section 1.9.17 in the C++ standard for more information.  
 
  Applying the postfix increment operator to a pointer to an array of objects of type **long** actually adds four to the internal representation of the pointer. This behavior causes the pointer, which previously referred to the *n*th element of the array, to refer to the (*n*+1)th element.  
 
  The operands to postfix increment and postfix decrement operators must be modifiable (not **const**) l-values of arithmetic or pointer type. The type of the result is the same as that of the *postfix-expression*, but it is no longer an l-value.  
 
-**Visual Studio 2017 version 15.3 and later** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)): The operand of a postfix increment  or decrement operator may not be of type `bool`.
+**Visual Studio 2017 version 15.3 and later** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)): The operand of a postfix increment  or decrement operator may not be of type **bool**.
 
  The following code illustrates the postfix increment operator:  
 

docs/cpp/private-cpp.md

@@ -22,9 +22,9 @@ private base-class
 ```  
 
 ## Remarks  
- When preceding a list of class members, the `private` keyword specifies that those members are accessible only from member functions and friends of the class. This applies to all members declared up to the next access specifier or the end of the class.  
+ When preceding a list of class members, the **private** keyword specifies that those members are accessible only from member functions and friends of the class. This applies to all members declared up to the next access specifier or the end of the class.  
 
- When preceding the name of a base class, the `private` keyword specifies that the public and protected members of the base class are private members of the derived class.  
+ When preceding the name of a base class, the **private** keyword specifies that the public and protected members of the base class are private members of the derived class.  
 
  Default access of members in a class is private. Default access of members in a structure or union is public.  
 
@@ -33,7 +33,7 @@ private base-class
  For related information, see [friend](../cpp/friend-cpp.md), [public](../cpp/public-cpp.md), [protected](../cpp/protected-cpp.md), and the member-access table in [Controlling Access to Class Members](member-access-control-cpp.md).  
 
 ## /clr Specific  
- In CLR types, the C++ access specifier keywords (**public**, `private`, and `protected`) can affect the visibility of types and methods with regard to assemblies. For more information, see [Member Access Control](member-access-control-cpp.md).  
+ In CLR types, the C++ access specifier keywords (**public**, **private**, and **protected**) can affect the visibility of types and methods with regard to assemblies. For more information, see [Member Access Control](member-access-control-cpp.md).  
 
 > [!NOTE]
 >  Files compiled with [/LN](../build/reference/ln-create-msil-module.md) are not affected by this behavior. In this case, all managed classes (either public or private) will be visible.  

docs/cpp/program-termination.md

@@ -18,7 +18,7 @@ In C++, there are several ways to exit a program:
 
 -   Call the [abort](../cpp/abort-function.md) function.  
 
--   Execute a [return](../cpp/return-statement-in-program-termination-cpp.md) statement from **main**.  
+-   Execute a [return](../cpp/return-statement-in-program-termination-cpp.md) statement from `main`.  
 
 ## See Also  
  [main: Program Startup](../cpp/main-program-startup.md)

docs/cpp/protected-cpp.md

@@ -22,7 +22,7 @@ protected base-class
 ```  
 
 ## Remarks  
- The `protected` keyword specifies access to class members in the *member-list* up to the next access specifier (**public** or `private`) or the end of the class definition. Class members declared as `protected` can be used only by the following:  
+ The **protected** keyword specifies access to class members in the *member-list* up to the next access specifier (**public** or **private**) or the end of the class definition. Class members declared as **protected** can be used only by the following:  
 
 -   Member functions of the class that originally declared these members.  
 
@@ -32,16 +32,16 @@ protected base-class
 
 -   Direct privately derived classes that also have private access to protected members.  
 
- When preceding the name of a base class, the `protected` keyword specifies that the public and protected members of the base class are protected members of its derived classes.  
+ When preceding the name of a base class, the **protected** keyword specifies that the public and protected members of the base class are protected members of its derived classes.  
 
- Protected members are not as private as `private` members, which are accessible only to members of the class in which they are declared, but they are not as public as **public** members, which are accessible in any function.  
+ Protected members are not as private as **private** members, which are accessible only to members of the class in which they are declared, but they are not as public as **public** members, which are accessible in any function.  
 
  Protected members that are also declared as **static** are accessible to any friend or member function of a derived class. Protected members that are not declared as **static** are accessible to friends and member functions in a derived class only through a pointer to, reference to, or object of the derived class.  
 
  For related information, see [friend](../cpp/friend-cpp.md), [public](../cpp/public-cpp.md), [private](../cpp/private-cpp.md), and the member-access table in [Controlling Access to Class Members](member-access-control-cpp.md).  
 
 ## /clr Specific  
- In CLR types, the C++ access specifier keywords (**public**, `private`, and `protected`) can affect the visibility of types and methods with regard to assemblies. For more information, see [Member Access Control](member-access-control-cpp.md).  
+ In CLR types, the C++ access specifier keywords (**public**, **private**, and **protected**) can affect the visibility of types and methods with regard to assemblies. For more information, see [Member Access Control](member-access-control-cpp.md).  
 
 > [!NOTE]
 >  Files compiled with [/LN](../build/reference/ln-create-msil-module.md) are not affected by this behavior. In this case, all managed classes (either public or private) will be visible.  

docs/cpp/ptr32-ptr64.md

@@ -16,7 +16,7 @@ ms.workload: ["cplusplus"]
 
 **Microsoft Specific**
 
-`__ptr32` represents a native pointer on a 32-bit system, while `__ptr64` represents a native pointer on a 64-bit system.
+**__ptr32** represents a native pointer on a 32-bit system, while **__ptr64** represents a native pointer on a 64-bit system.
 
 The following example shows how to declare each of these pointer types:
 
@@ -25,14 +25,14 @@ int * __ptr32 p32;
 int * __ptr64 p64;
 ```
 
- On a 32-bit system, a pointer declared with `__ptr64` is truncated to a 32-bit pointer. On a 64-bit system, a pointer declared with `__ptr32` is coerced to a 64-bit pointer.
+ On a 32-bit system, a pointer declared with **__ptr64** is truncated to a 32-bit pointer. On a 64-bit system, a pointer declared with **__ptr32** is coerced to a 64-bit pointer.
 
 > [!NOTE]
-> You cannot use `__ptr32` or `__ptr64` when compiling with **/clr:pure**. Otherwise, Compiler Error C2472 will be generated. The **/clr:pure** and **/clr:safe** compiler options are deprecated in Visual Studio 2015 and unsupported in Visual Studio 2017.
+> You cannot use **__ptr32** or **__ptr64** when compiling with **/clr:pure**. Otherwise, Compiler Error C2472 will be generated. The **/clr:pure** and **/clr:safe** compiler options are deprecated in Visual Studio 2015 and unsupported in Visual Studio 2017.
 
 ## Example
 
-The following example shows how to declare and allocate pointers with the `__ptr32` and `__ptr64` keywords.
+The following example shows how to declare and allocate pointers with the **__ptr32** and **__ptr64** keywords.
 
 ```cpp
 #include <cstdlib>

docs/cpp/public-cpp.md

@@ -33,7 +33,7 @@ public base-class
  For more information, see [private](../cpp/private-cpp.md), [protected](../cpp/protected-cpp.md), [friend](../cpp/friend-cpp.md), and the member-access table in [Controlling Access to Class Members](member-access-control-cpp.md).  
 
 ## /clr Specific  
- In CLR types, the C++ access specifier keywords (**public**, `private`, and `protected`) can affect the visibility of types and methods with regard to assemblies. For more information, see [Member Access Control](member-access-control-cpp.md).  
+ In CLR types, the C++ access specifier keywords (**public**, **private**, and **protected**) can affect the visibility of types and methods with regard to assemblies. For more information, see [Member Access Control](member-access-control-cpp.md).  
 
 > [!NOTE]
 >  Files compiled with [/LN](../build/reference/ln-create-msil-module.md) are not affected by this behavior. In this case, all managed classes (either public or private) will be visible.  

docs/cpp/raise.md

@@ -26,7 +26,7 @@ __raise method-declarator;
 ## Remarks  
  From managed code, an event can only be raised from within the class where it is defined. See [event](../windows/event-cpp-component-extensions.md) for more information.  
 
- The keyword `__raise` causes an error to be emitted if you call a non-event.  
+ The keyword **__raise** causes an error to be emitted if you call a non-event.  
 
 > [!NOTE]
 >  A templated class or struct cannot contain events.  

docs/cpp/raising-software-exceptions.md

@@ -20,7 +20,7 @@ Some of the most common sources of program errors are not flagged as exceptions
 
 -   Define your own exception code for the event.  
 
--   Call **RaiseException** when you detect a problem.  
+-   Call `RaiseException` when you detect a problem.  
 
 -   Use exception-handling filters to test for the exception code you defined.  
 

docs/cpp/range-based-for-statement-cpp.md

@@ -22,11 +22,11 @@ for ( for-range-declaration : expression )
 ```  
 
 ## Remarks  
- Use the range-based `for` statement to construct loops that must execute through a "range", which is defined as anything that you can iterate through—for example, `std::vector`, or any other C++ Standard Library sequence whose range is defined by a `begin()` and `end()`. The name that is declared in the `for-range-declaration` portion is local to the `for` statement and cannot be re-declared in `expression` or `statement`. Note that the [auto](../cpp/auto-cpp.md) keyword is preferred in the `for-range-declaration` portion of the statement. 
+ Use the range-based **for** statement to construct loops that must execute through a "range", which is defined as anything that you can iterate through—for example, `std::vector`, or any other C++ Standard Library sequence whose range is defined by a `begin()` and `end()`. The name that is declared in the `for-range-declaration` portion is local to the **for** statement and cannot be re-declared in `expression` or `statement`. Note that the [auto](../cpp/auto-cpp.md) keyword is preferred in the `for-range-declaration` portion of the statement. 
 
  **New in Visual Studio 2017:**  Range-based for loops no longer require that begin() and end() return objects of the same type. This enables end() to return a sentinel object such as used by ranges as defined in the Ranges-V3 proposal. For more information, see [Generalizing the Range-Based For Loop](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2016/p0184r0.html) and the [range-v3 library on GitHub](https://github.com/ericniebler/range-v3).
 
- This code shows how to use range-based `for` loops to iterate through an array and a vector:  
+ This code shows how to use range-based **for** loops to iterate through an array and a vector:  
 
 ```cpp  
 // range-based-for.cpp  
@@ -102,9 +102,9 @@ int main()
  `end of vector test`  
 ```
 
- A range-based `for` loop terminates when one of these in `statement` is executed: a [break](../cpp/break-statement-cpp.md), [return](../cpp/return-statement-cpp.md), or [goto](../cpp/goto-statement-cpp.md) to a labeled statement outside the range-based **for** loop. A [continue](../cpp/continue-statement-cpp.md) statement in a range-based `for` loop terminates only the current iteration.  
+ A range-based **for** loop terminates when one of these in `statement` is executed: a [break](../cpp/break-statement-cpp.md), [return](../cpp/return-statement-cpp.md), or [goto](../cpp/goto-statement-cpp.md) to a labeled statement outside the range-based **for** loop. A [continue](../cpp/continue-statement-cpp.md) statement in a range-based **for** loop terminates only the current iteration.  
 
- Keep in mind these facts about range-based `for`:  
+ Keep in mind these facts about range-based **for**:  
 
 -   Automatically recognizes arrays.  
 

docs/cpp/reference-type-function-returns.md

@@ -82,7 +82,7 @@ y = 9
 
  Declarations of reference types must contain initializers except in the following cases:  
 
--   Explicit `extern` declaration  
+-   Explicit **extern** declaration  
 
 -   Declaration of a class member  
 

docs/cpp/references-cpp.md

@@ -34,7 +34,7 @@ A reference, like a pointer, stores the address of an object that is located els
 
 -   An optional storage class specifier.  
 
--   Optional **const** and/or `volatile` qualifiers.  
+-   Optional **const** and/or **volatile** qualifiers.  
 
 -   The type specifier: the name of a type.  
 
@@ -44,7 +44,7 @@ A reference, like a pointer, stores the address of an object that is located els
 
 -   The & operator or && operator.  
 
--   Optional **const** and/or `volatile` qualifers.  
+-   Optional **const** and/or **volatile** qualifers.  
 
 -   The identifier.  
 

docs/cpp/reinterpret-cast-operator.md

@@ -22,17 +22,17 @@ reinterpret_cast < type-id > ( expression )
 ```  
 
 ## Remarks  
- Misuse of the `reinterpret_cast` operator can easily be unsafe. Unless the desired conversion is inherently low-level, you should use one of the other cast operators.  
+ Misuse of the **reinterpret_cast** operator can easily be unsafe. Unless the desired conversion is inherently low-level, you should use one of the other cast operators.  
 
- The `reinterpret_cast` operator can be used for conversions such as `char*` to `int*`, or `One_class*` to `Unrelated_class*`, which are inherently unsafe.  
+ The **reinterpret_cast** operator can be used for conversions such as `char*` to `int*`, or `One_class*` to `Unrelated_class*`, which are inherently unsafe.  
 
- The result of a `reinterpret_cast` cannot safely be used for anything other than being cast back to its original type. Other uses are, at best, nonportable.  
+ The result of a **reinterpret_cast** cannot safely be used for anything other than being cast back to its original type. Other uses are, at best, nonportable.  
 
- The `reinterpret_cast` operator cannot cast away the **const**, `volatile`, or **__unaligned** attributes. See [const_cast Operator](../cpp/const-cast-operator.md) for information on removing these attributes.  
+ The **reinterpret_cast** operator cannot cast away the **const**, **volatile**, or **__unaligned** attributes. See [const_cast Operator](../cpp/const-cast-operator.md) for information on removing these attributes.  
 
- The `reinterpret_cast` operator converts a null pointer value to the null pointer value of the destination type.  
+ The **reinterpret_cast** operator converts a null pointer value to the null pointer value of the destination type.  
 
- One practical use of `reinterpret_cast` is in a hash function, which maps a value to an index in such a way that two distinct values rarely end up with the same index.  
+ One practical use of **reinterpret_cast** is in a hash function, which maps a value to an index in such a way that two distinct values rarely end up with the same index.  
 
 ```cpp 
 #include <iostream>  
@@ -74,7 +74,7 @@ Output:
 64829  
 ```  
   
- The `reinterpret_cast` allows the pointer to be treated as an integral type. The result is then bit-shifted and XORed with itself to produce a unique index (unique to a high degree of probability). The index is then truncated by a standard C-style cast to the return type of the function.  
+ The **reinterpret_cast** allows the pointer to be treated as an integral type. The result is then bit-shifted and XORed with itself to produce a unique index (unique to a high degree of probability). The index is then truncated by a standard C-style cast to the return type of the function.  
   
 ## See Also  
  [Casting Operators](../cpp/casting-operators.md)   

docs/cpp/relational-function-templates.md

@@ -78,7 +78,7 @@ template<typename _Interface,
  *i*  
  A raw interface pointer.  
 
- `p`  
+ *p*  
  A smart pointer.  
 
 ## Remarks  

docs/cpp/relational-operators-equal-and-equal.md

@@ -33,7 +33,7 @@ expression >= expression
 
 -   Greater than or equal to (**>=**)  
 
- The relational operators have left-to-right associativity. Both operands of relational operators must be of arithmetic or pointer type. They yield values of type `bool`. The value returned is **false** (0) if the relationship in the expression is false; otherwise, the value returned is **true** (1).  
+ The relational operators have left-to-right associativity. Both operands of relational operators must be of arithmetic or pointer type. They yield values of type **bool**. The value returned is FALSE (0) if the relationship in the expression is false; otherwise, the value returned is TRUE (1).  
 
 ## Example