Fix another set of parameter issues

Colin Robertson · Colin Robertson · commit e6f162fd946d · 2018-09-13T17:49:00.000-07:00
diff --git a/docs/cpp/overloading-unary-operators.md b/docs/cpp/overloading-unary-operators.md
@@ -38,15 +38,15 @@ The unary operators that can be overloaded are the following:
   
  The following rules are true of all other unary operators. To declare a unary operator function as a nonstatic member, you must declare it in the form:  
   
- `ret-type operator` `op` `()`  
+> *ret-type* **operator** *op* **()**  
   
- where `ret-type` is the return type and `op` is one of the operators listed in the preceding table.  
+ where *ret-type* is the return type and *op* is one of the operators listed in the preceding table.  
   
  To declare a unary operator function as a global function, you must declare it in the form:  
   
- `ret-type operator` `op` (`arg` )  
+> *ret-type* **operator** *op* **(** *arg* **)**  
   
- where `ret-type` and `op` are as described for member operator functions and the `arg` is an argument of class type on which to operate.  
+ where *ret-type* and *op* are as described for member operator functions and the *arg* is an argument of class type on which to operate.  
   
 > [!NOTE]
 >  There is no restriction on the return types of the unary operators. For example, it makes sense for logical NOT (`!`) to return an integral value, but this is not enforced.  
diff --git a/docs/error-messages/tool-errors/linker-tools-error-lnk1120.md b/docs/error-messages/tool-errors/linker-tools-error-lnk1120.md
@@ -13,7 +13,8 @@ ms.author: "corob"
 ms.workload: ["cplusplus"]
 ---
 # Linker Tools Error LNK1120
-*number* unresolved externals  
+
+> *number* unresolved externals  
   
 Error LNK1120 reports the count (*number*) of unresolved external symbol errors for this link operation. Most unresolved external symbol errors are reported individually by [Linker Tools Error LNK2001](../../error-messages/tool-errors/linker-tools-error-lnk2001.md) and  [Linker Tools Error LNK2019](../../error-messages/tool-errors/linker-tools-error-lnk2019.md), which precede this error message, once for each unresolved external symbol error.  
   
diff --git a/docs/error-messages/tool-errors/linker-tools-error-lnk2005.md b/docs/error-messages/tool-errors/linker-tools-error-lnk2005.md
@@ -13,9 +13,10 @@ ms.author: "corob"
 ms.workload: ["cplusplus"]
 ---
 # Linker Tools Error LNK2005
-*symbol* already defined in object  
+
+> *symbol* already defined in object  
   
-The symbol *symbol* was defined more than once.   
+The symbol *symbol* was defined more than once.
   
 This error is followed by fatal error [LNK1169](../../error-messages/tool-errors/linker-tools-error-lnk1169.md).  
   
diff --git a/docs/intrinsics/arm-intrinsics.md b/docs/intrinsics/arm-intrinsics.md
@@ -229,8 +229,8 @@ void __iso_volatile_store8(volatile __int8 * Location, __int8 Value)
  `Location`  
  The address of a memory location to read from or write to.  
   
- `Value` (store intrinsics only)  
- The value to write to the specified memory location.  
+ `Value`  
+ The value to write to the specified memory location (store intrinsics only).  
   
  **Return Value (load intrinsics only)**  
   
@@ -240,9 +240,8 @@ void __iso_volatile_store8(volatile __int8 * Location, __int8 Value)
   
  You can use the `__iso_volatile_load8/16/32/64` and `__iso_volatile_store8/16/32/64` intrinsics to explicitly perform memory accesses that are not subject to compiler optimizations. The compiler cannot remove, synthetize, or change the relative order of these operations, but it does not generate implicit hardware memory barriers. Therefore, the hardware may still reorder the observable memory accesses across multiple threads. More precisely, these intrinsics are equivalent to the following expressions as compiled under **/volatile:iso**.  
   
-```  
-  
-      int a = __iso_volatile_load32(p);    // equivalent to: int a = *(const volatile __int32*)p;   
+```cpp
+int a = __iso_volatile_load32(p);    // equivalent to: int a = *(const volatile __int32*)p;   
 __iso_volatile_store32(p, a);        // equivalent to: *(volatile __int32*)p = a;  
 ```  
   
diff --git a/docs/mfc/reference/carray-class.md b/docs/mfc/reference/carray-class.md
@@ -22,12 +22,13 @@ template <class TYPE, class ARG_TYPE = const TYPE&>
 class CArray : public CObject  
 ```  
   
-#### Parameters  
- *TYPE*  
- Template parameter that specifies the type of objects stored in the array. *TYPE* is a parameter that is returned by `CArray`.  
-  
- *ARG* *_* *TYPE*  
- Template parameter that specifies the argument type that is used to access objects stored in the array. Often a reference to *TYPE*. *ARG_TYPE* is a parameter that is passed to `CArray`.  
+#### Parameters
+
+*TYPE*<br/>
+Template parameter that specifies the type of objects stored in the array. *TYPE* is a parameter that is returned by `CArray`.
+
+*ARG_TYPE*<br/>
+Template parameter that specifies the argument type that is used to access objects stored in the array. Often a reference to *TYPE*. *ARG_TYPE* is a parameter that is passed to `CArray`.  
   
 ## Members  
   
@@ -90,7 +91,7 @@ class CArray : public CObject
  `CArray`  
   
 ## Requirements  
- `Header:` afxtempl.h  
+**Header:** afxtempl.h  
   
 ##  <a name="add"></a>  CArray::Add  
  Adds a new element to the end of an array, growing the array by 1.  
diff --git a/docs/mfc/reference/clist-class.md b/docs/mfc/reference/clist-class.md
@@ -60,7 +60,7 @@ class CList : public CObject
  *TYPE*  
  Type of object stored in the list.  
   
- *ARG* *_* *TYPE*  
+ *ARG_TYPE*  
  Type used to reference objects stored in the list. Can be a reference.  
   
 ## Remarks  
diff --git a/docs/mfc/reference/cspinbuttonctrl-class.md b/docs/mfc/reference/cspinbuttonctrl-class.md
@@ -315,9 +315,10 @@ void SetRange32(
     int nUpper);
 ```  
   
-### Parameters  
- *nLower* and *nUpper*  
- Upper and lower limits for the control. For `SetRange`, neither limit can be greater than UD_MAXVAL or less than UD_MINVAL; in addition, the difference between the two limits cannot exceed UD_MAXVAL. `SetRange32` places no restrictions on the limits; use any integers.  
+### Parameters
+
+*nLower* and *nUpper*<br/>
+Upper and lower limits for the control. For `SetRange`, neither limit can be greater than UD_MAXVAL or less than UD_MINVAL; in addition, the difference between the two limits cannot exceed UD_MAXVAL. `SetRange32` places no restrictions on the limits; use any integers.  
   
 ### Remarks  
  The member function `SetRange32` sets the 32-bit range for the spin button control.  
diff --git a/docs/parallel/amp/reference/concurrency-precise-math-namespace-functions.md b/docs/parallel/amp/reference/concurrency-precise-math-namespace-functions.md
@@ -1471,8 +1471,8 @@ inline double modf(
 `_X`  
 Floating-point value
 
-`_Iptr` (out parameter)  
-The integer portion of `_X`, as a floating-point value.
+`_Iptr`  
+[out] The integer portion of `_X`, as a floating-point value.
 
 ### Return Value
 The signed fractional portion of `_X`.
@@ -1798,8 +1798,8 @@ The first floating-point argument.
 `_Y`  
 The second floating-point argument.
 
-`_Quo` (out parameter)  
-The address of an integer that’s used to return the quotient of the fractional bits of `_X` divided by the fractional bits of `_Y`.
+`_Quo`  
+[out] The address of an integer that’s used to return the quotient of the fractional bits of `_X` divided by the fractional bits of `_Y`.
 
 ### Return Value
 Returns the remainder of `_X` divided by `_Y`.
@@ -1821,8 +1821,8 @@ The first floating-point argument.
 `_Y`  
 The second floating-point argument.
 
-`_Quo` (out parameter)  
-The address of an integer that’s used to return the quotient of the fractional bits of `_X` divided by the fractional bits of `_Y`.
+`_Quo`  
+[out] The address of an integer that’s used to return the quotient of the fractional bits of `_X` divided by the fractional bits of `_Y`.
 
 ### Return Value
 Returns the remainder of `_X` divided by `_Y`.
diff --git a/docs/standard-library/algorithm-functions.md b/docs/standard-library/algorithm-functions.md
@@ -2316,11 +2316,11 @@ Returns **true** if the elements in the specified range form a heap, **false** i
 
 ### Remarks
 
-The first template function returns [is_heap_until](../standard-library/algorithm-functions.md#is_heap_until)`(` `first ,` `last ) ==` `last`.
+The first template function returns [is_heap_until](../standard-library/algorithm-functions.md#is_heap_until)`(first , last) == last`.
 
 The second template function returns
 
-`is_heap_until` `(`  `first` `,`  `last` `,`  `comp` `) ==`  `last`.
+`is_heap_until(first, last, comp) == last`.
 
 ## <a name="is_heap_until"></a>  is_heap_until
 
diff --git a/docs/standard-library/allocators-header.md b/docs/standard-library/allocators-header.md
@@ -36,9 +36,10 @@ An allocator is a template class that describes an object that manages storage a
 
 The allocators are all templates of this type:
 
-`template<class` `Type` `>`
-
-`class allocator;`
+```cpp
+template<class Type>
+class allocator;
+```
 
 where the template argument `Type` is the type managed by the allocator instance. The C++ Standard Library provides a default allocator, template class [allocator](../standard-library/allocator-class.md), which is defined in [\<memory>](../standard-library/memory.md). The \<allocators> header provides the following allocators:
 
diff --git a/docs/standard-library/istream-iterator-class.md b/docs/standard-library/istream-iterator-class.md
@@ -248,9 +248,9 @@ The value of a member, if any.
 
 ### Remarks
 
-*i* -> is equivalent to (\* *i*). *m*
+`i->m` is equivalent to `(*i).m`
 
-The operator returns **&\*\*this**.
+The operator returns `&*this`.
 
 ### Example
 
diff --git a/docs/standard-library/raw-storage-iterator-class.md b/docs/standard-library/raw-storage-iterator-class.md
@@ -270,8 +270,8 @@ int main( void )
    int *pInt = new int[5];
    std::raw_storage_iterator<int*,int> it( pInt );
    for ( int i = 0; i < 5; i++, it++ ) {
-*it = 2 * i;
-};
+      *it = 2 * i;
+   };
 
    for ( int i = 0; i < 5; i++ ) cout << "array " << i << " = " << pInt[i] << endl;;
 
diff --git a/docs/windows/arrays-cpp-component-extensions.md b/docs/windows/arrays-cpp-component-extensions.md
@@ -45,23 +45,23 @@ The first example of the syntax uses the **ref new** aggregate keyword to alloca
     {initialization-list [,...]}
 ```
 
-*qualifiers* [optional]
- One or more of these storage class specifiers: [mutable](../cpp/mutable-data-members-cpp.md), [volatile](../cpp/volatile-cpp.md), [const](../cpp/const-cpp.md), [extern](../cpp/using-extern-to-specify-linkage.md), [static](../cpp/static-members-cpp.md).
+*qualifiers*<br/>
+(Optional) One or more of these storage class specifiers: [mutable](../cpp/mutable-data-members-cpp.md), [volatile](../cpp/volatile-cpp.md), [const](../cpp/const-cpp.md), [extern](../cpp/using-extern-to-specify-linkage.md), [static](../cpp/static-members-cpp.md).
 
 *array-type*  
 The type of the array variable. Valid types are Windows Runtime classes and fundamental types, ref classes and structs, value classes and structs, and native pointers (`type*`).
 
-*rank* [optional]
- The number of dimensions of the array. Must be 1.
+*rank*<br/>
+(Optional) The number of dimensions of the array. Must be 1.
 
 *identifier*  
 The name of the array variable.
 
 *initialization-type*  
 The type of the values that initialize the array. Typically, *array-type* and *initialization-type* are the same type. However, the types can be different if there is a conversion from *initialization-type* to *array-type*—for example, if *initialization-type* is derived from *array-type*.
 
-*initialization-list* [optional]
- A comma-delimited list of values in curly brackets that initialize the elements of the array. For example, if *rank-size-list* were `(3)`, which declares a one-dimensional array of 3 elements, *initialization list* could be `{1,2,3}`.
+*initialization-list*<br/>
+(Optional) A comma-delimited list of values in curly brackets that initialize the elements of the array. For example, if *rank-size-list* were `(3)`, which declares a one-dimensional array of 3 elements, *initialization list* could be `{1,2,3}`.
 
 ### Remarks
 
@@ -101,14 +101,14 @@ The first example of the syntax uses the **gcnew** keyword to allocate an array.
     {initialization-list [,...]}
 ```
 
-*qualifiers* [optional]
- One or more of these storage class specifiers: [mutable](../cpp/mutable-data-members-cpp.md), [volatile](../cpp/volatile-cpp.md), [const](../cpp/const-cpp.md), [extern](../cpp/using-extern-to-specify-linkage.md), [static](../cpp/static-members-cpp.md).
+*qualifiers*<br/>
+(Optional) One or more of these storage class specifiers: [mutable](../cpp/mutable-data-members-cpp.md), [volatile](../cpp/volatile-cpp.md), [const](../cpp/const-cpp.md), [extern](../cpp/using-extern-to-specify-linkage.md), [static](../cpp/static-members-cpp.md).
 
 *array-type*  
 The type of the array variable. Valid types are Windows Runtime classes and fundamental types, ref classes and structs, value classes and structs, native pointers (`type*`), and native POD (plain old data) types.
 
-*rank* [optional]
- The number of dimensions of the array. The default is 1; the maximum is 32. Each dimension of the array is itself an array.
+*rank*<br/>
+(Optional) The number of dimensions of the array. The default is 1; the maximum is 32. Each dimension of the array is itself an array.
 
 *identifier*  
 The name of the array variable.
@@ -119,8 +119,8 @@ The type of the values that initialize the array. Typically, *array-type* and *i
 *rank-size-list*  
 A comma-delimited list of the size of each dimension in the array. Alternatively, if the *initialization-list* parameter is specified, the compiler can deduce the size of each dimension and *rank-size-list* can be omitted.
 
-*initialization-list* [optional]
- A comma-delimited list of values in curly brackets that initialize the elements of the array. Or a comma-delimited list of nested *initialization-list* items that initialize the elements in a multi-dimensional array.
+*initialization-list*<br/>
+(Optional) A comma-delimited list of values in curly brackets that initialize the elements of the array. Or a comma-delimited list of nested *initialization-list* items that initialize the elements in a multi-dimensional array.
 
 For example, if *rank-size-list* were `(3)`, which declares a one-dimensional array of 3 elements, *initialization list* could be `{1,2,3}`. If *rank-size-list* were `(3,2,4)`, which declares a three-dimensional array of 3 elements in the first dimension, 2 elements in the second, and 4 elements in the third, *initialization-list* could be `{{1,2,3},{0,0},{-5,10,-21,99}}`.)
 
diff --git a/docs/windows/generic-classes-cpp-cli.md b/docs/windows/generic-classes-cpp-cli.md
@@ -44,7 +44,7 @@ Either **class** or **typename**
 *constraint-clauses*  
 A list (not comma-separated) of **where** clauses specifying the constraints for the type parameters. Takes the form:
 
-`where`  *type-parameter-identifier*  `:`  *constraint-list*  `...`
+> **where** *type-parameter-identifier* **:** *constraint-list*  **...**
 
 *constraint-list*  
 *class-or-interface*[`,` *...*]
