Merge pull request #1072 from msebolt/format-standard-pr13

format standard pr13

Author: TrishaMc

docs/standard-library/reverse-iterator-class.md

@@ -253,7 +253,7 @@ reverse_iterator<RandomIterator> operator+(difference_type Off) const;
 
 ### Parameters
 
-`Off`
+*Off*
  The offset to be added to the reverse iterator.
 
 ### Return Value
@@ -402,7 +402,7 @@ reverse_iterator<RandomIterator>& operator+=(difference_type Off);
 
 ### Parameters
 
-`Off`
+*Off*
  The offset by which to increment the iterator.
 
 ### Return Value
@@ -475,7 +475,7 @@ reverse_iterator<RandomIterator> operator-(difference_type Off) const;
 
 ### Parameters
 
-`Off`
+*Off*
  The offset to be subtracted from the reverse_iterator.
 
 ### Return Value
@@ -625,7 +625,7 @@ reverse_iterator<RandomIterator>& operator-=(difference_type Off);
 
 ### Parameters
 
-`Off`
+*Off*
  The offset to be subtracted from the `reverse_iterator`.
 
 ### Remarks
@@ -779,7 +779,7 @@ reference operator[](difference_type Off) const;
 
 ### Parameters
 
-`Off`
+*Off*
  The offset from the `reverse_iterator` address.
 
 ### Return Value
@@ -933,7 +933,7 @@ The type is a synonym for the iterator trait typename `iterator_traits`\< *Rando
 
 ### Example
 
-See [reverse_iterator::operator&#91;&#93;](#op_at) or [reverse_iterator::operator*](#op_star) for examples of how to declare and use **reference**.
+See [reverse_iterator::operator&#91;&#93;](#op_at) or [reverse_iterator::operator*](#op_star) for examples of how to declare and use `reference`.
 
 ## <a name="reverse_iterator"></a>  reverse_iterator::reverse_iterator
 
@@ -949,7 +949,7 @@ reverse_iterator(const reverse_iterator<Type>& right);
 
 ### Parameters
 
-`right`
+*right*
  The iterator that is to be adapted to a `reverse_iterator`.
 
 ### Return Value

docs/standard-library/rts-alloc-class.md

@@ -27,7 +27,7 @@ class rts_alloc
 
 |Parameter|Description|
 |---------------|-----------------|
-|`Cache`|The type of cache instances contained in the array. This can be [cache_chunklist Class](../standard-library/cache-chunklist-class.md), [cache_freelist](../standard-library/cache-freelist-class.md), or [cache_suballoc](../standard-library/cache-suballoc-class.md).|
+|*Cache*|The type of cache instances contained in the array. This can be [cache_chunklist Class](../standard-library/cache-chunklist-class.md), [cache_freelist](../standard-library/cache-freelist-class.md), or [cache_suballoc](../standard-library/cache-suballoc-class.md).|
 
 ## Remarks
 
@@ -59,15 +59,15 @@ void *allocate(std::size_t count);
 
 |Parameter|Description|
 |---------------|-----------------|
-|`count`|The number of elements in the array to be allocated.|
+|*count*|The number of elements in the array to be allocated.|
 
 ### Return Value
 
 A pointer to the allocated object.
 
 ### Remarks
 
-The member function returns `caches[_IDX].allocate(count)`, where the index `_IDX` is determined by the requested block size `count`, or, if `count` is too large, it returns `operator new(count)`. `cache`, which represents the cache object.
+The member function returns `caches[_IDX].allocate(count)`, where the index `_IDX` is determined by the requested block size *count*, or, if *count* is too large, it returns `operator new(count)`. `cache`, which represents the cache object.
 
 ## <a name="deallocate"></a>  rts_alloc::deallocate
 
@@ -81,12 +81,12 @@ void deallocate(void* ptr, std::size_t count);
 
 |Parameter|Description|
 |---------------|-----------------|
-|`ptr`|A pointer to the first object to be deallocated from storage.|
-|`count`|The number of objects to be deallocated from storage.|
+|*ptr*|A pointer to the first object to be deallocated from storage.|
+|*count*|The number of objects to be deallocated from storage.|
 
 ### Remarks
 
-The member function calls `caches[_IDX].deallocate(ptr, count)`, where the index `_IDX` is determined by the requested block size `count`, or, if `count` is too large, it returns `operator delete(ptr)`.
+The member function calls `caches[_IDX].deallocate(ptr, count)`, where the index `_IDX` is determined by the requested block size *count*, or, if *count* is too large, it returns `operator delete(ptr)`.
 
 ## <a name="equals"></a>  rts_alloc::equals
 
@@ -100,12 +100,12 @@ bool equals(const sync<_Cache>& _Other) const;
 
 |Parameter|Description|
 |---------------|-----------------|
-|`_Cache`|The cache object associated with the filter.|
-|`_Other`|The cache object to compare for equality.|
+|*_Cache*|The cache object associated with the filter.|
+|*_Other*|The cache object to compare for equality.|
 
 ### Remarks
 
-`true` if the result of `caches[0].equals(other.caches[0])`; otherwise, `false`. `caches` represents the array of cache objects.
+**true** if the result of `caches[0].equals(other.caches[0])`; otherwise, **false**. `caches` represents the array of cache objects.
 
 ## See also
 

docs/standard-library/sample-container-class.md

@@ -16,13 +16,13 @@ ms.workload: ["cplusplus"]
 > [!NOTE]
 > This topic is in the Visual C++ documentation as a nonfunctional example of containers used in the C++ Standard Library. For more information, see [C++ Standard Library Containers](../standard-library/stl-containers.md).
 
-Describes an object that controls a varying-length sequence of elements, typically of type **Ty**. The sequence is stored in different ways, depending on the actual container.
+Describes an object that controls a varying-length sequence of elements, typically of type `Ty`. The sequence is stored in different ways, depending on the actual container.
 
 A container constructor or member function may find occasion to call the constructor **Ty**(**const Ty&**) or the function **Ty::operator=**(**const Ty&**). If such a call throws an exception, the container object is obliged to maintain its integrity, and to rethrow any exception it catches. You can safely swap, assign to, erase, or destroy a container object after it throws one of these exceptions. In general, however, you cannot otherwise predict the state of the sequence controlled by the container object.
 
 A few additional caveats:
 
-- If the expression **~Ty** throws an exception, the resulting state of the container object is undefined.
+- If the expression `~Ty` throws an exception, the resulting state of the container object is undefined.
 
 - If the container stores an allocator object *al*, and *al* throws an exception other than as a result of a call to *al***.allocate**, the resulting state of the container object is undefined.
 
@@ -32,9 +32,9 @@ The container classes defined by C++ Standard Library satisfy several additional
 
 Container template class [list](../standard-library/list-class.md) provides deterministic, and useful, behavior even in the presence of the exceptions described above. For example, if an exception is thrown during the insertion of one or more elements, the container is left unaltered and the exception is rethrown.
 
-For *all* the container classes defined by C++ Standard Library, if an exception is thrown during calls to the following member functions, **insert**, **push_back**, or **push_front**, the container is left unaltered and the exception is rethrown.
+For *all* the container classes defined by C++ Standard Library, if an exception is thrown during calls to the following member functions, `insert`, `push_back`, or `push_front`, the container is left unaltered and the exception is rethrown.
 
-For *all* the container classes defined by C++ Standard Library, no exception is thrown during calls to the following member functions: **pop_back**, **pop_front**.
+For *all* the container classes defined by C++ Standard Library, no exception is thrown during calls to the following member functions: `pop_back`, `pop_front`.
 
 The member function [erase](../standard-library/container-class-erase.md) throws an exception only if a copy operation (assignment or copy construction) throws an exception.
 
@@ -46,29 +46,29 @@ The member function [swap](../standard-library/container-class-swap.md) makes ad
 
 - References, pointers, and iterators that designate elements of the controlled sequences being swapped remain valid.
 
-An object of a container class defined by C++ Standard Library allocates and frees storage for the sequence it controls through a stored object of type `Alloc`, which is typically a template parameter. Such an allocator object must have the same external interface as an object of class **allocator\<Ty>**. In particular, `Alloc` must be the same type as **Alloc::rebind<value_type>::other**
+An object of a container class defined by C++ Standard Library allocates and frees storage for the sequence it controls through a stored object of type `Alloc`, which is typically a template parameter. Such an allocator object must have the same external interface as an object of class `allocator<Ty>`. In particular, `Alloc` must be the same type as `Alloc::rebind<value_type>::other`
 
-For *all* container classes defined by C++ Standard Library, the member function **Alloc get_allocator const;** returns a copy of the stored allocator object. Note that the stored allocator object is *not* copied when the container object is assigned. All constructors initialize the value stored in **allocator**, to `Alloc` if the constructor contains no allocator parameter.
+For *all* container classes defined by C++ Standard Library, the member function `Alloc get_allocator const;` returns a copy of the stored allocator object. Note that the stored allocator object is *not* copied when the container object is assigned. All constructors initialize the value stored in `allocator`, to `Alloc` if the constructor contains no allocator parameter.
 
 According to the C++ Standard, a container class defined by the C++ Standard Library can assume that:
 
 - All objects of class `Alloc` compare equal.
 
-- Type **Alloc::const_pointer** is the same as **const Ty \***.
+- Type `Alloc::const_pointer` is the same as `const Ty *`.
 
-- Type **Alloc::const_reference** is the same as **const Ty&**.
+- Type `Alloc::const_reference` is the same as `const Ty&`.
 
-- Type **Alloc::pointer** is the same as **Ty \***.
+- Type `Alloc::pointer` is the same as `Ty *`.
 
-- Type **Alloc::reference** is the same as **Ty&**.
+- Type `Alloc::reference` is the same as `Ty&`.
 
 In this implementation, however, containers do not make such simplifying assumptions. Thus, they work properly with allocator objects that are more ambitious:
 
 - All objects of class `Alloc` does not need to compare equal. (You can maintain multiple pools of storage.)
 
-- Type **Alloc::const_pointer** does not need to be the same as **const Ty \***. (A const pointer can be a class.)
+- Type `Alloc::const_pointer` does not need to be the same as `const Ty *`. (A const pointer can be a class.)
 
-- Type **Alloc::pointer** does not need to be the same as **Ty \***. (A pointer can be a class.)
+- Type `Alloc::pointer` does not need to be the same as `Ty *`. (A pointer can be a class.)
 
 ## Requirements
 

docs/standard-library/sample-container-members.md

@@ -30,7 +30,7 @@ ms.workload: ["cplusplus"]
 |[reference](../standard-library/container-class-reference.md)|Describes an object that can serve as a reference to an element of the controlled sequence.|
 |[reverse_iterator](../standard-library/container-class-reverse-iterator.md)|Describes an object that can serve as a reverse iterator for the controlled sequence.|
 |[size_type](../standard-library/container-class-size-type.md)|Describes an object that can represent the length of any controlled sequence.|
-|[value_type](../standard-library/container-class-value-type.md)|Acts a synonym for the template parameter **Ty**.|
+|[value_type](../standard-library/container-class-value-type.md)|Acts a synonym for the template parameter `Ty`.|
 
 ## Member Functions
 

docs/standard-library/scl-secure-no-warnings.md

@@ -14,7 +14,7 @@ ms.workload: ["cplusplus"]
 ---
 # _SCL_SECURE_NO_WARNINGS
 
-Calling any of the potentially unsafe methods in the C++ Standard Library results in [Compiler Warning (level 3) C4996](../error-messages/compiler-warnings/compiler-warning-level-3-c4996.md). To disable this warning, define the macro **_SCL_SECURE_NO_WARNINGS** in your code:
+Calling any of the potentially unsafe methods in the C++ Standard Library results in [Compiler Warning (level 3) C4996](../error-messages/compiler-warnings/compiler-warning-level-3-c4996.md). To disable this warning, define the macro _SCL_SECURE_NO_WARNINGS in your code:
 
 ```cpp
 #define _SCL_SECURE_NO_WARNINGS

docs/standard-library/scoped-allocator-adaptor-class.md

@@ -103,10 +103,10 @@ pointer allocate(size_type count);pointer allocate(size_type count, const_void_p
 
 ### Parameters
 
-`count`
+*count*
  The number of elements for which sufficient storage is to be allocated.
 
-`hint`
+*hint*
  A pointer that might assist the allocator object by locating the address of an object allocated prior to the request.
 
 ### Return Value
@@ -142,32 +142,32 @@ void construct(pair<Ty1, Ty2>* ptr, pair<Uy1, Uy2>&& right);
 
 ### Parameters
 
-`ptr`
+*ptr*
  A pointer to the memory location where the object is to be constructed.
 
-`args`
+*args*
  A list of arguments.
 
-`first`
+*first*
  An object of the first type in a pair.
 
-`second`
+*second*
  An object of the second type in a pair.
 
-`right`
+*right*
  An existing object to be moved or copied.
 
 ### Remarks
 
-The first method constructs the object at `ptr` by calling `Outermost_traits::construct(OUTERMOST(*this), ptr, xargs...)`, where `xargs...` is one of the following.
+The first method constructs the object at *ptr* by calling `Outermost_traits::construct(OUTERMOST(*this), ptr, xargs...)`, where `xargs...` is one of the following.
 
 - If `uses_allocator<Ty, inner_allocator_type>` holds false, then `xargs...` is `args...`.
 
 - If `uses_allocator<Ty, inner_allocator_type>` holds true, and `is_constructible<Ty, allocator_arg_t, inner_allocator_type, args...>` holds true, then `xargs...` is `allocator_arg, inner_allocator(), args...`.
 
 - If `uses_allocator<Ty, inner_allocator_type>` holds true, and `is_constructible<Ty, args..., inner_allocator()>` holds true, then `xargs...` is `args..., inner_allocator()`.
 
-The second method constructs the pair object at `ptr` by calling `Outermost_traits::construct(OUTERMOST(*this), &ptr->first, xargs...)`, where `xargs...` is `first...` modified as in the above list, and `Outermost_traits::construct(OUTERMOST(*this), &ptr->second, xargs...)`, where `xargs...` is `second...` modified as in the above list.
+The second method constructs the pair object at *ptr* by calling `Outermost_traits::construct(OUTERMOST(*this), &ptr->first, xargs...)`, where `xargs...` is `first...` modified as in the above list, and `Outermost_traits::construct(OUTERMOST(*this), &ptr->second, xargs...)`, where `xargs...` is `second...` modified as in the above list.
 
 The third method behaves the same as `this->construct(ptr, piecewise_construct, tuple<>, tuple<>)`.
 
@@ -187,10 +187,10 @@ void deallocate(pointer ptr, size_type count);
 
 ### Parameters
 
-`ptr`
+*ptr*
  A pointer to the starting location of the objects to be deallocated.
 
-`count`
+*count*
  The number of objects to deallocate.
 
 ## <a name="destroy"></a>  scoped_allocator_adaptor::destroy
@@ -204,7 +204,7 @@ void destroy(Ty* ptr)
 
 ### Parameters
 
-`ptr`
+*ptr*
  A pointer to the object to be destroyed.
 
 ### Return Value
@@ -280,18 +280,18 @@ scoped_allocator_adaptor(Outer2&& al,
 
 ### Parameters
 
-`right`
+*right*
  An existing `scoped_allocator_adaptor`.
 
-`al`
+*al*
  An existing allocator to be used as the outer allocator.
 
-`rest`
+*rest*
  A list of allocators to be used as the inner allocators.
 
 ### Remarks
 
-The first constructor default constructs its stored allocator objects. Each of the next three constructors constructs its stored allocator objects from the corresponding objects in `right`. The last constructor constructs its stored allocator objects from the corresponding arguments in the argument list.
+The first constructor default constructs its stored allocator objects. Each of the next three constructors constructs its stored allocator objects from the corresponding objects in *right*. The last constructor constructs its stored allocator objects from the corresponding arguments in the argument list.
 
 ## <a name="select_on_container_copy_construction"></a>  scoped_allocator_adaptor::select_on_container_copy_construction
 
@@ -303,7 +303,7 @@ scoped_allocator_adaptor select_on_container_copy_construction();
 
 ### Return Value
 
-This method effectively returns `scoped_allocator_adaptor(Outer_traits::select_on_container_copy_construction(*this), inner_allocator().select_on_container_copy_construction())`. The result is a new `scoped_allocator_adaptor` object with each stored allocator object initialized by calling `al.select_on_container_copy_construction()` for the corresponding allocator `al`.
+This method effectively returns `scoped_allocator_adaptor(Outer_traits::select_on_container_copy_construction(*this), inner_allocator().select_on_container_copy_construction())`. The result is a new `scoped_allocator_adaptor` object with each stored allocator object initialized by calling `al.select_on_container_copy_construction()` for the corresponding allocator *al*.
 
 ## See also
 

docs/standard-library/scoped-allocator-operators.md

@@ -26,10 +26,10 @@ bool operator!=(
 
 ### Parameters
 
-`left`
+*left*
  The left `scoped_allocator_adaptor` object.
 
-`right`
+*right*
  The right `scoped_allocator_adaptor` object.
 
 ### Return Value
@@ -49,10 +49,10 @@ bool operator==(
 
 ### Parameters
 
-`left`
+*left*
  The left `scoped_allocator_adaptor` object.
 
-`right`
+*right*
  The right `scoped_allocator_adaptor` object.
 
 ### Return Value

docs/standard-library/secure-scl.md

@@ -17,17 +17,17 @@ ms.workload: ["cplusplus"]
 Superseded by [_ITERATOR_DEBUG_LEVEL](../standard-library/iterator-debug-level.md), this macro defines whether [Checked Iterators](../standard-library/checked-iterators.md) are enabled. By default, checked iterators are enabled in Debug builds, and disabled in Retail builds.
 
 > [!IMPORTANT]
-> Direct use of the `_SECURE_SCL` macro is deprecated. Instead, use `_ITERATOR_DEBUG_LEVEL` to control checked iterator settings. For more information, see [_ITERATOR_DEBUG_LEVEL](../standard-library/iterator-debug-level.md).
+> Direct use of the _SECURE_SCL macro is deprecated. Instead, use _ITERATOR_DEBUG_LEVEL to control checked iterator settings. For more information, see [_ITERATOR_DEBUG_LEVEL](../standard-library/iterator-debug-level.md).
 
 ## Remarks
 
-When checked iterators are enabled, unsafe iterator use causes a runtime error and the program is terminated. To enable checked iterators, set `_ITERATOR_DEBUG_LEVEL` to 1 or 2. This is equivalent to a `_SECURE_SCL` setting of 1, or enabled:
+When checked iterators are enabled, unsafe iterator use causes a runtime error and the program is terminated. To enable checked iterators, set _ITERATOR_DEBUG_LEVEL to 1 or 2. This is equivalent to a _SECURE_SCL setting of 1, or enabled:
 
 ```cpp
 #define _ITERATOR_DEBUG_LEVEL 1
 ```
 
-To disable checked iterators, set `_ITERATOR_DEBUG_LEVEL` to 0. This is equivalent to a `_SECURE_SCL` setting of 0, or disabled:
+To disable checked iterators, set _ITERATOR_DEBUG_LEVEL to 0. This is equivalent to a _SECURE_SCL setting of 0, or disabled:
 
 ```cpp
 #define _ITERATOR_DEBUG_LEVEL 0