Merge pull request #1069 from msebolt/format-standard-pr11

format standard pr11

Author: TrishaMc

docs/standard-library/negate-struct.md

@@ -37,11 +37,11 @@ struct negate<void>
 
 ### Parameters
 
-`Type`
+*Type*
  Any type that supports an `operator-` that takes an operand of the specified or inferred type.
 
-`Left`
- The operand to be negated. The specialized template does perfect forwarding of lvalue and rvalue reference arguments of inferred type `Type`.
+*Left*
+ The operand to be negated. The specialized template does perfect forwarding of lvalue and rvalue reference arguments of inferred type *Type*.
 
 ## Return Value
 

docs/standard-library/negative-binomial-distribution-class.md

@@ -46,15 +46,16 @@ public:
     result_type min() const;
     result_type max() const;
 };
+```
 
 ### Parameters
 
 *IntType*
-The integer result type, defaults to `int`. For possible types, see [\<random>](../standard-library/random.md).
+The integer result type, defaults to **int**. For possible types, see [\<random>](../standard-library/random.md).
 
 ## Remarks
 
-The template class describes a distribution that produces values of a user-specified integral type, or type `int` if none is provided, distributed according to the Negative Binomial Distribution discrete probability function. The following table links to articles about individual members.
+The template class describes a distribution that produces values of a user-specified integral type, or type **int** if none is provided, distributed according to the Negative Binomial Distribution discrete probability function. The following table links to articles about individual members.
 
 ||||
 |-|-|-|

docs/standard-library/new-functions.md

@@ -14,7 +14,7 @@ ms.assetid: e250f06a-b025-4509-ae7a-5356d56aad7d
 
 ## <a name="nothrow"></a>  nothrow
 
-Provides an object to be used as an argument for the `nothrow` versions of **new** and **delete**.
+Provides an object to be used as an argument for the **nothrow** versions of **new** and **delete**.
 
 ```cpp
 extern const std::nothrow_t nothrow;
@@ -30,24 +30,24 @@ See [operator new](../standard-library/new-operators.md#op_new) and [operator ne
 
 ## <a name="set_new_handler"></a>  set_new_handler
 
-Installs a user function that is to be called when `operator new` fails in its attempt to allocate memory.
+Installs a user function that is to be called when **operator new** fails in its attempt to allocate memory.
 
 ```cpp
 new_handler set_new_handler(new_handler Pnew) throw();
 ```
 
 ### Parameters
 
-`Pnew`
- The new_handler to be installed.
+*Pnew*  
+The `new_handler` to be installed.
 
 ### Return Value
 
 0 on the first call and the previous `new_handler` on subsequent calls.
 
 ### Remarks
 
-The function stores `Pnew` in a static [new handler](../standard-library/new-typedefs.md#new_handler) pointer that it maintains, then returns the value previously stored in the pointer. The new handler is used by [operator new](../standard-library/new-operators.md#op_new)( **size_t**).
+The function stores *Pnew* in a static [new handler](../standard-library/new-typedefs.md#new_handler) pointer that it maintains, then returns the value previously stored in the pointer. The new handler is used by [operator new](../standard-library/new-operators.md#op_new)(**size_t**).
 
 ### Example
 

docs/standard-library/new-operators.md

@@ -29,22 +29,22 @@ void operator delete(void* ptr,
 
 ### Parameters
 
-`ptr`
+*ptr*
  The pointer whose value is to be rendered invalid by the deletion.
 
 ### Remarks
 
-The first function is called by a delete expression to render the value of `ptr` invalid. The program can define a function with this function signature that replaces the default version defined by the C++ Standard Library. The required behavior is to accept a value of `ptr` that is null or that was returned by an earlier call to [operator new](../standard-library/new-operators.md#op_new)( **size_t**).
+The first function is called by a delete expression to render the value of *ptr* invalid. The program can define a function with this function signature that replaces the default version defined by the C++ Standard Library. The required behavior is to accept a value of *ptr* that is null or that was returned by an earlier call to [operator new](../standard-library/new-operators.md#op_new)(**size_t**).
 
-The default behavior for a null value of `ptr` is to do nothing. Any other value of `ptr` must be a value returned earlier by a call as previously described. The default behavior for such a nonnull value of `ptr` is to reclaim storage allocated by the earlier call. It is unspecified under what conditions part or all of such reclaimed storage is allocated by a subsequent call to `operator new`( **size_t**), or to any of `calloc`( **size_t**), `malloc`( **size_t**), or `realloc`( **void\***, **size_t**).
+The default behavior for a null value of *ptr* is to do nothing. Any other value of *ptr* must be a value returned earlier by a call as previously described. The default behavior for such a nonnull value of *ptr* is to reclaim storage allocated by the earlier call. It is unspecified under what conditions part or all of such reclaimed storage is allocated by a subsequent call to `operator new`(**size_t**), or to any of `calloc`( **size_t**), `malloc`( **size_t**), or `realloc`( **void\***, **size_t**).
 
 The second function is called by a placement delete expression corresponding to a new expression of the form **new**( **std::size_t**). It does nothing.
 
-The third function is called by a placement delete expression corresponding to a new expression of the form **new**( **std::size_t**, **conststd::nothrow_t&**). The program can define a function with this function signature that replaces the default version defined by the C++ Standard Library. The required behavior is to accept a value of `ptr` that is null or that was returned by an earlier call to `operator new`( **size_t**). The default behavior is to evaluate **delete**( `ptr`).
+The third function is called by a placement delete expression corresponding to a new expression of the form **new**( **std::size_t**, **conststd::nothrow_t&**). The program can define a function with this function signature that replaces the default version defined by the C++ Standard Library. The required behavior is to accept a value of `ptr` that is null or that was returned by an earlier call to `operator new`( **size_t**). The default behavior is to evaluate **delete**(`ptr`).
 
 ### Example
 
-See [operator new](../standard-library/new-operators.md#op_new) for an example that use `operator delete`.
+See [operator new](../standard-library/new-operators.md#op_new) for an example that use **operator delete**.
 
 ## <a name="op_delete_arr"></a>  operator delete[]
 
@@ -62,16 +62,16 @@ void operator delete[](void* ptr,
 
 ### Parameters
 
-`ptr`
+*ptr*
  The pointer whose value is to be rendered invalid by the deletion.
 
 ### Remarks
 
-The first function is called by an `delete[]` expression to render the value of `ptr` invalid. The function is replaceable because the program can define a function with this function signature that replaces the default version defined by the C++ Standard Library. The required behavior is to accept a value of `ptr` that is null or that was returned by an earlier call to [operator new&#91;&#93;](../standard-library/new-operators.md#op_new_arr)( **size_t**). The default behavior for a null value of `ptr` is to do nothing. Any other value of `ptr` must be a value returned earlier by a call as previously described. The default behavior for such a nonnull value of `ptr` is to reclaim storage allocated by the earlier call. It is unspecified under what conditions part or all of such reclaimed storage is allocated by a subsequent call to [operator new](../standard-library/new-operators.md#op_new)( **size_t**), or to any of `calloc`( **size_t**), `malloc`( **size_t**), or `realloc`( **void\***, **size_t**).
+The first function is called by an `delete[]` expression to render the value of *ptr* invalid. The function is replaceable because the program can define a function with this function signature that replaces the default version defined by the C++ Standard Library. The required behavior is to accept a value of *ptr* that is null or that was returned by an earlier call to [operator new&#91;&#93;](../standard-library/new-operators.md#op_new_arr)(**size_t**). The default behavior for a null value of *ptr* is to do nothing. Any other value of *ptr* must be a value returned earlier by a call as previously described. The default behavior for such a nonnull value of *ptr* is to reclaim storage allocated by the earlier call. It is unspecified under what conditions part or all of such reclaimed storage is allocated by a subsequent call to [operator new](../standard-library/new-operators.md#op_new)(**size_t**), or to any of `calloc`(**size_t**), `malloc`(**size_t**), or `realloc`( **void\***, **size_t**).
 
-The second function is called by a placement `delete[]` expression corresponding to a `new[]` expression of the form `new[]`( **std::size_t**). It does nothing.
+The second function is called by a placement `delete[]` expression corresponding to a `new[]` expression of the form `new[]`(**std::size_t**). It does nothing.
 
-The third function is called by a placement delete expression corresponding to a `new[]` expression of the form `new[]`( **std::size_t**, **const std::nothrow_t&**). The program can define a function with this function signature that replaces the default version defined by the C++ Standard Library. The required behavior is to accept a value of `ptr` that is null or that was returned by an earlier call to operator `new[]`( **size_t**). The default behavior is to evaluate `delete[]`( `ptr`).
+The third function is called by a placement delete expression corresponding to a `new[]` expression of the form `new[]`( **std::size_t**, **const std::nothrow_t&**). The program can define a function with this function signature that replaces the default version defined by the C++ Standard Library. The required behavior is to accept a value of *ptr* that is null or that was returned by an earlier call to operator `new[]`(**size_t**). The default behavior is to evaluate `delete[]`( `ptr`).
 
 ### Example
 
@@ -93,15 +93,15 @@ void* operator new(std::size_t count,
 
 ### Parameters
 
-`count`
+*count*
  The number of bytes of storage to be allocated.
 
-`ptr`
+*ptr*
  The pointer to be returned.
 
 ### Return Value
 
-A pointer to the lowest byte address of the newly-allocated storage. Or `ptr.`
+A pointer to the lowest byte address of the newly-allocated storage. Or *ptr*.
 
 ### Remarks
 
@@ -115,21 +115,21 @@ The required behavior of a new handler is to perform one of the following operat
 
 - Make more storage available for allocation and then return.
 
-- Call either **abort** or **exit**( `int`).
+- Call either **abort** or **exit**(`int`).
 
 - Throw an object of type **bad_alloc.**
 
 The default behavior of a [new handler](../standard-library/new-typedefs.md#new_handler) is to throw an object of type `bad_alloc`. A null pointer designates the default new handler.
 
-The order and contiguity of storage allocated by successive calls to `operator new`( **size_t**) is unspecified, as are the initial values stored there.
+The order and contiguity of storage allocated by successive calls to `operator new`(**size_t**) is unspecified, as are the initial values stored there.
 
 The second function is called by a placement new expression to allocate `count` bytes of storage suitably aligned to represent any object of that size. The program can define an alternate function with this function signature that replaces the default version defined by the C++ Standard Library and so is replaceable.
 
-The default behavior is to return `operator new`( `count`) if that function succeeds. Otherwise, it returns a null pointer.
+The default behavior is to return `operator new`(`count`) if that function succeeds. Otherwise, it returns a null pointer.
 
 The third function is called by a placement **new** expression, of the form **new** ( *args*) T. Here, *args* consists of a single object pointer. This can be useful for constructing an object at a known address. The function returns *ptr*.
 
-To free storage allocated by `operator new`, call [operator delete](../standard-library/new-operators.md#op_delete).
+To free storage allocated by **operator new**, call [operator delete](../standard-library/new-operators.md#op_delete).
 
 For information on throwing or nonthrowing behavior of new, see [The new and delete Operators](../cpp/new-and-delete-operators.md).
 
@@ -192,21 +192,21 @@ void* operator new[](std::size_t count,
 
 ### Parameters
 
-`count`
+*count*
  The number of bytes of storage to be allocated for the array object.
 
-`ptr`
+*ptr*
  The pointer to be returned.
 
 ### Return Value
 
-A pointer to the lowest byte address of the newly-allocated storage. Or `ptr.`
+A pointer to the lowest byte address of the newly-allocated storage. Or *ptr*.
 
 ### Remarks
 
-The first function is called by a `new[]` expression to allocate `count` bytes of storage suitably aligned to represent any array object of that size or smaller. The program can define a function with this function signature that replaces the default version defined by the C++ Standard Library. The required behavior is the same as for [operator new](../standard-library/new-operators.md#op_new)( **size_t**). The default behavior is to return `operator new`( `count`).
+The first function is called by a `new[]` expression to allocate `count` bytes of storage suitably aligned to represent any array object of that size or smaller. The program can define a function with this function signature that replaces the default version defined by the C++ Standard Library. The required behavior is the same as for [operator new](../standard-library/new-operators.md#op_new)(**size_t**). The default behavior is to return `operator new`( `count`).
 
-The second function is called by a placement `new[]` expression to allocate `count` bytes of storage suitably aligned to represent any array object of that size. The program can define a function with this function signature that replaces the default version defined by the C++ Standard Library. The default behavior is to return **operatornew**( `count`) if that function succeeds. Otherwise, it returns a null pointer.
+The second function is called by a placement `new[]` expression to allocate `count` bytes of storage suitably aligned to represent any array object of that size. The program can define a function with this function signature that replaces the default version defined by the C++ Standard Library. The default behavior is to return **operatornew**(`count`) if that function succeeds. Otherwise, it returns a null pointer.
 
 The third function is called by a placement `new[]` expression, of the form **new** ( *args*) **T**[ **N**]. Here, *args* consists of a single object pointer. The function returns `ptr`.
 

docs/standard-library/new.md

@@ -31,7 +31,7 @@ Some of the functions declared in this header are replaceable. The implementatio
 
 |||
 |-|-|
-|[nothrow](../standard-library/new-functions.md#nothrow)|Provides an object to be used as an argument for the `nothrow` versions of **new** and **delete**.|
+|[nothrow](../standard-library/new-functions.md#nothrow)|Provides an object to be used as an argument for the **nothrow** versions of **new** and **delete**.|
 
 ### Typedefs
 

docs/standard-library/normal-distribution-class.md

@@ -51,18 +51,18 @@ public:
 ### Parameters
 
 *RealType*
-The floating-point result type, defaults to `double`. For possible types, see [\<random>](../standard-library/random.md).
+The floating-point result type, defaults to **double**. For possible types, see [\<random>](../standard-library/random.md).
 
 ## Remarks
 
-The template class describes a distribution that produces values of a user-specified integral type, or type `double` if none is provided, distributed according to the Normal Distribution. The following table links to articles about individual members.
+The template class describes a distribution that produces values of a user-specified integral type, or type **double** if none is provided, distributed according to the Normal Distribution. The following table links to articles about individual members.
 
 ||||
 |-|-|-|
 |[normal_distribution](#normal_distribution)|`normal_distribution::mean`|`normal_distribution::param`|
 |`normal_distribution::operator()`|`normal_distribution::stddev`|[param_type](#param_type)|
 
-The property functions `mean()` and `stddev()` return the values for the stored distribution parameters `mean` and `stddev` respectively.
+The property functions `mean()` and `stddev()` return the values for the stored distribution parameters *mean* and *stddev* respectively.
 
 The property member `param()` sets or returns the `param_type` stored distribution parameter package.
 

docs/standard-library/not-equal-to-struct.md

@@ -14,7 +14,7 @@ ms.workload: ["cplusplus"]
 ---
 # not_equal_to Struct
 
-A binary predicate that performs the inequality operation ( `operator!=`) on its arguments.
+A binary predicate that performs the inequality operation (`operator!=`) on its arguments.
 
 ## Syntax
 
@@ -37,22 +37,22 @@ struct not_equal_to<void>
 
 ### Parameters
 
-`Type`, `T`, `U`
+*Type*, *T*, *U*
  Any type that supports an `operator!=` that takes operands of the specified or inferred types.
 
-`Left`
- The left operand of the inequality operation. The unspecialized template takes an lvalue reference argument of type `Type`. The specialized template does perfect forwarding of lvalue and rvalue reference arguments of inferred type `T`.
+*Left*
+ The left operand of the inequality operation. The unspecialized template takes an lvalue reference argument of type *Type*. The specialized template does perfect forwarding of lvalue and rvalue reference arguments of inferred type *T*.
 
-`Right`
- The right operand of the inequality operation. The unspecialized template takes an lvalue reference argument of type `Type`. The specialized template does perfect forwarding of lvalue and rvalue reference arguments of inferred type `U`.
+*Right*
+ The right operand of the inequality operation. The unspecialized template takes an lvalue reference argument of type *Type*. The specialized template does perfect forwarding of lvalue and rvalue reference arguments of inferred type *U*.
 
 ## Return Value
 
 The result of `Left != Right`. The specialized template does perfect forwarding of the result, which has the type that's returned by `operator!=`.
 
 ## Remarks
 
-The objects of type `Type` must be equality-comparable. This requires that the `operator!=` defined on the set of objects satisfies the mathematical properties of an equivalence relation. All of the built-in numeric and pointer types satisfy this requirement.
+The objects of type *Type* must be equality-comparable. This requires that the `operator!=` defined on the set of objects satisfies the mathematical properties of an equivalence relation. All of the built-in numeric and pointer types satisfy this requirement.
 
 ## Example