dcshen
diff --git a/‎docs/cpp/com-ptr-t-queryinterface.md‎
Lines changed: 5 additions & 5 deletions b/‎docs/cpp/com-ptr-t-queryinterface.md‎
Lines changed: 5 additions & 5 deletions
diff --git a/‎docs/cpp/com-ptr-t-relational-operators.md‎
Lines changed: 2 additions & 2 deletions b/‎docs/cpp/com-ptr-t-relational-operators.md‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎docs/cpp/com-ptr-t-release.md‎
Lines changed: 2 additions & 2 deletions b/‎docs/cpp/com-ptr-t-release.md‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎docs/cpp/com-raise-error.md‎
Lines changed: 5 additions & 5 deletions b/‎docs/cpp/com-raise-error.md‎
Lines changed: 5 additions & 5 deletions
diff --git a/‎docs/cpp/compiler-com-support-classes.md‎
Lines changed: 2 additions & 2 deletions b/‎docs/cpp/compiler-com-support-classes.md‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎docs/cpp/compiler-com-support.md‎
Lines changed: 1 addition & 1 deletion b/‎docs/cpp/compiler-com-support.md‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎docs/cpp/compiler-limits.md‎
Lines changed: 2 additions & 2 deletions b/‎docs/cpp/compiler-limits.md‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎docs/cpp/conditional-operator-q.md‎
Lines changed: 2 additions & 2 deletions b/‎docs/cpp/conditional-operator-q.md‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎docs/cpp/considerations-for-writing-prolog-epilog-code.md‎
Lines changed: 4 additions & 4 deletions b/‎docs/cpp/considerations-for-writing-prolog-epilog-code.md‎
Lines changed: 4 additions & 4 deletions
diff --git a/‎docs/cpp/const-and-volatile-pointers.md‎
Lines changed: 7 additions & 7 deletions b/‎docs/cpp/const-and-volatile-pointers.md‎
Lines changed: 7 additions & 7 deletions
@@ -15,7 +15,7 @@ ms.workload: ["cplusplus"]
 # _com_ptr_t::QueryInterface
 **Microsoft Specific**  
 
- Calls the `QueryInterface` member function of **IUnknown** on the encapsulated interface pointer.  
+ Calls the `QueryInterface` member function of `IUnknown` on the encapsulated interface pointer.  
 
 ## Syntax  
 
@@ -32,14 +32,14 @@ template<typename _InterfaceType> HRESULT QueryInterface (
 ```  
 
 #### Parameters  
- `iid`  
- **IID** of an interface pointer.  
+ *iid*  
+ `IID` of an interface pointer.  
 
- `p`  
+ *p*  
  Raw interface pointer.  
 
 ## Remarks  
- Calls **IUnknown::QueryInterface** on the encapsulated interface pointer with the specified **IID** and returns the resulting raw interface pointer in `p`. This routine returns the `HRESULT` to indicate success or failure.  
+ Calls `IUnknown::QueryInterface` on the encapsulated interface pointer with the specified `IID` and returns the resulting raw interface pointer in *p*. This routine returns the HRESULT to indicate success or failure.  
 
  **END Microsoft Specific**  
 
 
@@ -15,7 +15,7 @@ ms.workload: ["cplusplus"]
 # _com_ptr_t Relational Operators
 **Microsoft Specific**  
 
- Compare the smart pointer object to another smart pointer, raw interface pointer, or **NULL**.  
+ Compare the smart pointer object to another smart pointer, raw interface pointer, or NULL.  
 
 ## Syntax  
 
@@ -90,7 +90,7 @@ bool operator>=( _InterfaceType* p );
 ```  
 
 ## Remarks  
- Compares a smart pointer object to another smart pointer, raw interface pointer, or **NULL**. Except for the **NULL** pointer tests, these operators first query both pointers for **IUnknown**, and compare the results.  
+ Compares a smart pointer object to another smart pointer, raw interface pointer, or NULL. Except for the NULL pointer tests, these operators first query both pointers for `IUnknown`, and compare the results.  
 
  **END Microsoft Specific**  
 
 
@@ -15,7 +15,7 @@ ms.workload: ["cplusplus"]
 # _com_ptr_t::Release
 **Microsoft Specific**  
 
- Calls the **Release** member function of **IUnknown** on the encapsulated interface pointer.  
+ Calls the `Release` member function of `IUnknown` on the encapsulated interface pointer.  
 
 ## Syntax  
 
@@ -26,7 +26,7 @@ void Release( );
 ```  
 
 ## Remarks  
- Calls `IUnknown::Release` on the encapsulated interface pointer, raising an `E_POINTER` error if this interface pointer is **NULL**.  
+ Calls `IUnknown::Release` on the encapsulated interface pointer, raising an E_POINTER error if this interface pointer is NULL.  
 
  **END Microsoft Specific**  
 
 
@@ -28,14 +28,14 @@ void __stdcall _com_raise_error(
 ```  
 
 #### Parameters  
- `hr`  
- `HRESULT` information.  
+ *hr*  
+ HRESULT information.  
 
- `perrinfo`  
- **IErrorInfo** object.  
+ *perrinfo*  
+ `IErrorInfo` object.  
 
 ## Remarks  
- `_com_raise_error`, which is defined in \<comdef.h>, can be replaced by a user-written version of the same name and prototype. This could be done if you want to use `#import` but do not want to use C++ exception handling. In that case, a user version of **_com_raise_error** might decide to do a `longjmp` or display a message box and halt. The user version should not return, though, because the compiler COM support code does not expect it to return.  
+ `_com_raise_error`, which is defined in \<comdef.h>, can be replaced by a user-written version of the same name and prototype. This could be done if you want to use `#import` but do not want to use C++ exception handling. In that case, a user version of `_com_raise_error` might decide to do a `longjmp` or display a message box and halt. The user version should not return, though, because the compiler COM support code does not expect it to return.  
 
  You can also use [_set_com_error_handler](../cpp/set-com-error-handler.md) to replace the default error-handling function.  
 
 
@@ -21,8 +21,8 @@ ms.workload: ["cplusplus"]
 |-----------|-------------|  
 |[_bstr_t](../cpp/bstr-t-class.md)|Wraps the `BSTR` type to provide useful operators and methods.|  
 |[_com_error](../cpp/com-error-class.md)|Defines the error object thrown by [_com_raise_error](../cpp/com-raise-error.md) in most failures.|  
-|[_com_ptr_t](../cpp/com-ptr-t-class.md)|Encapsulates COM interface pointers, and automates the required calls to `AddRef`, **Release**, and `QueryInterface`.|  
-|[_variant_t](../cpp/variant-t-class.md)|Wraps the **VARIANT** type to provide useful operators and methods.|  
+|[_com_ptr_t](../cpp/com-ptr-t-class.md)|Encapsulates COM interface pointers, and automates the required calls to `AddRef`, `Release`, and `QueryInterface`.|  
+|[_variant_t](../cpp/variant-t-class.md)|Wraps the `VARIANT` type to provide useful operators and methods.|  
 
 **END Microsoft Specific**  
 
 
@@ -19,7 +19,7 @@ ms.workload: ["cplusplus"]
 
  You can use the [__declspec](../cpp/declspec.md) extended attribute [uuid](../cpp/uuid-cpp.md) to assign a globally unique identifier (GUID) to a COM object. The keyword [__uuidof](../cpp/uuidof-operator.md) can be used to extract the GUID associated with a COM object. Another `__declspec` attribute, [property](../cpp/property-cpp.md), can be used to specify the **get** and **set** methods for a data member of a COM object.  
 
- A set of COM support global functions and classes is provided to support the **VARIANT** and `BSTR` types, implement smart pointers, and encapsulate the error object thrown by `_com_raise_error`:  
+ A set of COM support global functions and classes is provided to support the `VARIANT` and `BSTR` types, implement smart pointers, and encapsulate the error object thrown by `_com_raise_error`:  
 
 -   [Compiler COM Global Functions](../cpp/compiler-com-global-functions.md)  
 
 
@@ -20,15 +20,15 @@ The C++ standard recommends limits for various language constructs. The followin
 
 -   Arguments in one macro invocation - C++ standard: 256, Visual C++ compiler 127.  
 
--   Characters in a character string literal or wide string literal (after concatenation) - C++ standard: 65536, Visual C++ compiler: 65535 single-byte characters, including the `null` terminator, and 32767 double-byte characters, including the `null` terminator.  
+-   Characters in a character string literal or wide string literal (after concatenation) - C++ standard: 65536, Visual C++ compiler: 65535 single-byte characters, including the NULL terminator, and 32767 double-byte characters, including the NULL terminator.  
 
 -   Levels of nested class, structure, or union definitions in a single `struct-declaration-list` - C++ standard: 256, Visual C++ compiler: 16.  
 
 -   Member initializers in a constructor definition - C++ standard: 6144, Visual C++ compiler: at least 6144.  
 
 -   Scope qualifications of one identifier - C++ standard: 256, Visual C++ compiler: 127.  
 
--   Nested `extern` specifications - C++ standard: 1024, Visual C++ compiler: 9 (not counting the implicit `extern` specification in global scope, or 10, if you count the implicit `extern` specification in global scope..  
+-   Nested **extern** specifications - C++ standard: 1024, Visual C++ compiler: 9 (not counting the implicit **extern** specification in global scope, or 10, if you count the implicit **extern** specification in global scope..  
 
 -   Template arguments in a template declaration - C++ standard: 1024, Visual C++ compiler: 2046.  
 
 
@@ -25,9 +25,9 @@ expression ? expression : expression
 
 -   The first operand is implicitly converted to `bool`. It is evaluated and all side effects are completed before continuing.  
 
--   If the first operand evaluates to **true** (1), the second operand is evaluated.  
+-   If the first operand evaluates to TRUE (1), the second operand is evaluated.  
 
--   If the first operand evaluates to **false** (0), the third operand is evaluated.  
+-   If the first operand evaluates to FALSE (0), the third operand is evaluated.  
 
  The result of the conditional operator is the result of whichever operand is evaluated — the second or the third. Only one of the last two operands is evaluated in a conditional expression.  
 
 
@@ -13,7 +13,7 @@ ms.workload: ["cplusplus"]
 ---
 # Considerations for Writing Prolog/Epilog Code
 ## Microsoft Specific  
- Before writing your own prolog and epilog code sequences, it is important to understand how the stack frame is laid out. It is also useful to know how to use the **__LOCAL_SIZE** symbol.  
+ Before writing your own prolog and epilog code sequences, it is important to understand how the stack frame is laid out. It is also useful to know how to use the __LOCAL_SIZE symbol.  
 
 ##  <a name="_pluslang_c.2b2b_.stack_frame_layout"></a> Stack Frame Layout  
  This example shows the standard prolog code that might appear in a 32-bit function:  
@@ -37,16 +37,16 @@ ret                       ; Return from function
  The stack always grows down (from high to low memory addresses). The base pointer (`ebp`) points to the pushed value of `ebp`. The locals area begins at `ebp-4`. To access local variables, calculate an offset from `ebp` by subtracting the appropriate value from `ebp`.  
 
 ##  <a name="_pluslang___local_size"></a> __LOCAL_SIZE  
- The compiler provides a symbol, **__LOCAL_SIZE**, for use in the inline assembler block of function prolog code. This symbol is used to allocate space for local variables on the stack frame in custom prolog code.  
+ The compiler provides a symbol, __LOCAL_SIZE, for use in the inline assembler block of function prolog code. This symbol is used to allocate space for local variables on the stack frame in custom prolog code.  
 
- The compiler determines the value of **__LOCAL_SIZE**. Its value is the total number of bytes of all user-defined local variables and compiler-generated temporary variables. **__LOCAL_SIZE** can be used only as an immediate operand; it cannot be used in an expression. You must not change or redefine the value of this symbol. For example:  
+ The compiler determines the value of __LOCAL_SIZE. Its value is the total number of bytes of all user-defined local variables and compiler-generated temporary variables. __LOCAL_SIZE can be used only as an immediate operand; it cannot be used in an expression. You must not change or redefine the value of this symbol. For example:  
 
 ```  
 mov        eax, __LOCAL_SIZE           ;Immediate operand--Okay  
 mov        eax, [ebp - __LOCAL_SIZE]   ;Error  
 ```  
 
- The following example of a naked function containing custom prolog and epilog sequences uses the **__LOCAL_SIZE** symbol in the prolog sequence:  
+ The following example of a naked function containing custom prolog and epilog sequences uses the __LOCAL_SIZE symbol in the prolog sequence:  
 
 ```  
 // the__local_size_symbol.cpp  
 
@@ -14,18 +14,18 @@ ms.workload: ["cplusplus"]
 # const and volatile Pointers
 The [const](../cpp/const-cpp.md) and [volatile](../cpp/volatile-cpp.md) keywords change how pointers are treated. The **const** keyword specifies that the pointer cannot be modified after initialization; the pointer is protected from modification thereafter.  
 
- The `volatile` keyword specifies that the value associated with the name that follows can be modified by actions other than those in the user application. Therefore, the `volatile` keyword is useful for declaring objects in shared memory that can be accessed by multiple processes or global data areas used for communication with interrupt service routines.  
+ The **volatile** keyword specifies that the value associated with the name that follows can be modified by actions other than those in the user application. Therefore, the **volatile** keyword is useful for declaring objects in shared memory that can be accessed by multiple processes or global data areas used for communication with interrupt service routines.  
 
- When a name is declared as `volatile`, the compiler reloads the value from memory each time it is accessed by the program. This dramatically reduces the possible optimizations. However, when the state of an object can change unexpectedly, it is the only way to ensure predictable program performance.  
+ When a name is declared as **volatile**, the compiler reloads the value from memory each time it is accessed by the program. This dramatically reduces the possible optimizations. However, when the state of an object can change unexpectedly, it is the only way to ensure predictable program performance.  
 
- To declare the object pointed to by the pointer as **const** or `volatile`, use a declaration of the form:  
+ To declare the object pointed to by the pointer as **const** or **volatile**, use a declaration of the form:  
 
 ```cpp 
 const char *cpch;  
 volatile char *vpch;  
 ```  
 
- To declare the value of the pointer — that is, the actual address stored in the pointer — as **const** or `volatile`, use a declaration of the form:  
+ To declare the value of the pointer — that is, the actual address stored in the pointer — as **const** or **volatile**, use a declaration of the form:  
 
 ```cpp 
 char * const pchc;  
@@ -57,7 +57,7 @@ char *pch2 = &cch;   // Error
 char *const pch3 = &cch;   // Error  
 ```  
 
- The declaration of `pch2` declares a pointer through which a constant object might be modified and is therefore disallowed. The declaration of `pch3` specifies that the `pointer` is constant, not the object; the declaration is disallowed for the same reason the `pch2` declaration is disallowed.  
+ The declaration of `pch2` declares a pointer through which a constant object might be modified and is therefore disallowed. The declaration of `pch3` specifies that the **pointer** is constant, not the object; the declaration is disallowed for the same reason the `pch2` declaration is disallowed.  
 
  The following eight assignments show assigning through pointer and changing of pointer value for the preceding declarations; for now, assume that the initialization was correct for `pch1` through `pch8`.  
 
@@ -72,15 +72,15 @@ pch3 = &ch;   // Error: pointer declared const
 pch4 = &ch;   // Error: pointer declared const  
 ```  
 
- Pointers declared as `volatile`, or as a mixture of **const** and `volatile`, obey the same rules.  
+ Pointers declared as **volatile**, or as a mixture of **const** and **volatile**, obey the same rules.  
 
  Pointers to **const** objects are often used in function declarations as follows:  
 
 ```cpp 
 errno_t strcpy_s( char *strDestination, size_t numberOfElements, const char *strSource );  
 ```  
   
- The preceding statement declares a function, [strcpy_s](../c-runtime-library/reference/strcpy-s-wcscpy-s-mbscpy-s.md), where two of the three arguments are of type pointer to `char`. Because the arguments are passed by reference and not by value, the function would be free to modify both `strDestination` and `strSource` if `strSource` were not declared as **const**. The declaration of `strSource` as **const** assures the caller that `strSource` cannot be changed by the called function.  
+ The preceding statement declares a function, [strcpy_s](../c-runtime-library/reference/strcpy-s-wcscpy-s-mbscpy-s.md), where two of the three arguments are of type pointer to **char**. Because the arguments are passed by reference and not by value, the function would be free to modify both `strDestination` and `strSource` if `strSource` were not declared as **const**. The declaration of `strSource` as **const** assures the caller that `strSource` cannot be changed by the called function.  
   
 > [!NOTE]
 >  Because there is a standard conversion from *typename* **\*** to **const** *typename* **\***, it is legal to pass an argument of type **char \*** to [strcpy_s](../c-runtime-library/reference/strcpy-s-wcscpy-s-mbscpy-s.md). However, the reverse is not true; no implicit conversion exists to remove the **const** attribute from an object or pointer.