Remove backslash and square bracket entities

3836425+corob-msft@users.noreply.github.com · 3836425+corob-msft@users.noreply.github.com · commit 7e78ba7361ae · 2021-11-10T23:27:42.000-08:00
diff --git a/docs/build/reference/fe-name-exe-file.md b/docs/build/reference/fe-name-exe-file.md
@@ -22,7 +22,7 @@ The relative or absolute path and base file name, or relative or absolute path t
 
 ## Remarks
 
-The **/Fe** option allows you to specify the output directory, output executable name, or both, for the generated executable file. If *pathname* ends in a path separator (**&#92;**), it is assumed to specify only the output directory. Otherwise, the last component of *pathname* is used as the output file base name, and the rest of *pathname* specifies the output directory. If *pathname* does not have any path separators, it's assumed to specify the output file name in the current directory. The *pathname* must be enclosed in double quotes (**"**) if it contains any characters that can't be in a short path, such as spaces, extended characters, or path components more than eight characters long.
+The **/Fe** option allows you to specify the output directory, output executable name, or both, for the generated executable file. If *pathname* ends in a path separator (**`\`**), it is assumed to specify only the output directory. Otherwise, the last component of *pathname* is used as the output file base name, and the rest of *pathname* specifies the output directory. If *pathname* does not have any path separators, it's assumed to specify the output file name in the current directory. The *pathname* must be enclosed in double quotes (**"**) if it contains any characters that can't be in a short path, such as spaces, extended characters, or path components more than eight characters long.
 
 When the **/Fe** option is not specified, or when a file base name is not specified in *pathname*, the compiler gives the output file a default name using the base name of the first source or object file specified on the command line and the extension .exe or .dll.
 
diff --git a/docs/c-runtime-library/reference/chdir-wchdir.md b/docs/c-runtime-library/reference/chdir-wchdir.md
@@ -42,7 +42,7 @@ The **_chdir** function changes the current working directory to the directory s
 _chdir("c:\temp");
 ```
 
-When you use the optional backslash character (**&#92;**) in paths, you must place two backslashes (**&#92;&#92;**) in a C string literal to represent a single backslash (**&#92;**).
+When you use the optional backslash character (**`\`**) in paths, you must place two backslashes (**`\\`**) in a C string literal to represent a single backslash (**`\`**).
 
 **_wchdir** is a wide-character version of **_chdir**; the *dirname* argument to **_wchdir** is a wide-character string. **_wchdir** and **_chdir** behave identically otherwise.
 
diff --git a/docs/standard-library/reverse-iterator-class.md b/docs/standard-library/reverse-iterator-class.md
@@ -67,7 +67,7 @@ In practice, this means that in the reversed sequence the reverse_iterator will
 |[operator--](#operator--)|Decrements the `reverse_iterator` to the previous element.|
 |[operator-=](#operator-_eq)|Subtracts a specified offset from a `reverse_iterator`.|
 |[operator->](#op-arrow)|Returns a pointer to the element addressed by the `reverse_iterator`.|
-|[operator&#91;&#93;](#op_at)|Returns a reference to an element offset from the element addressed by a `reverse_iterator` by a specified number of positions.|
+|[`operator[]`](#op_at)|Returns a reference to an element offset from the element addressed by a `reverse_iterator` by a specified number of positions.|
 
 ## Requirements
 
@@ -160,7 +160,7 @@ The type is a synonym for the iterator trait typename `iterator_traits`\< **Rand
 
 ### Example
 
-See [reverse_iterator::operator&#91;&#93;](#op_at) for an example of how to declare and use `difference_type`.
+See [`reverse_iterator::operator[]`](#op_at) for an example of how to declare and use `difference_type`.
 
 ## <a name="iterator_type"></a> reverse_iterator::iterator_type
 
@@ -927,7 +927,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[]`](#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
 
diff --git a/docs/standard-library/slice-array-class.md b/docs/standard-library/slice-array-class.md
@@ -39,9 +39,9 @@ The class describes an object that stores a reference to an object of class [val
 
 The class template is created indirectly by certain valarray operations and cannot be used directly in the program. An internal, auxiliary class template that is used by the slice subscript operator:
 
-`slice_array`\< **Type**> `valarray`< **Type**:: `operator[]` ( `slice`).
+`slice_array<Type> valarray<Type>::operator[]( slice )`.
 
-You construct a `slice_array<Type>` object only by writing an expression of the form [va&#91;sl&#93;](../standard-library/valarray-class.md#op_at), for a slice `sl` of valarray `va`. The member functions of class slice_array then behave like the corresponding function signatures defined for `valarray<Type>`, except that only the sequence of selected elements is affected. The sequence controlled by the slice_array is defined by the three parameters of the slice constructor, the index of the first element in the slice, the number of elements, and the distance between the elements. A slice_array cut from valarray `va` declared by **va**[ `slice`(2, 5, 3)] selects elements with indices 2, 5, 8, 11, and 14 from `va`. The indices must be valid for the procedure to be valid.
+You construct a `slice_array<Type>` object only by writing an expression of the form [`va[sl]`](../standard-library/valarray-class.md#op_at), for a slice `sl` of valarray `va`. The member functions of class `slice_array` then behave like the corresponding function signatures defined for `valarray<Type>`, except that only the sequence of selected elements is affected. The sequence controlled by the `slice_array` is defined by the three parameters of the slice constructor, the index of the first element in the slice, the number of elements, and the distance between the elements. A slice_array cut from valarray `va` declared by **va**[ `slice`(2, 5, 3)] selects elements with indices 2, 5, 8, 11, and 14 from `va`. The indices must be valid for the procedure to be valid.
 
 ## Example
 
diff --git a/docs/standard-library/valarray-class.md b/docs/standard-library/valarray-class.md
@@ -16,7 +16,7 @@ The class is a representation of the mathematical concept of an ordered set of v
 
 - It defines numerous arithmetic operations between corresponding elements of `valarray<Type>` objects of the same type and length, such as *xarr* = cos( *yarr*) + sin( *zarr*).
 
-- It defines a variety of interesting ways to subscript a `valarray<Type>` object, by overloading [operator&#91;&#93;](#op_at).
+- It defines a variety of interesting ways to subscript a `valarray<Type>` object, by overloading [`operator[]`](#op_at).
 
 An object of class `Type`:
 
@@ -71,9 +71,9 @@ In particular, no subtle differences may exist between copy construction and def
 |[operator-=](#operator-_eq)|Subtracts the elements of a specified `valarray` or a value of the element type, element-wise, from an operand `valarray`.|
 |[operator/=](#op_div_eq)|Divides an operand `valarray` element-wise by the elements of a specified `valarray` or a value of the element type.|
 |[operator=](#op_eq)|Assigns elements to a `valarray` whose values are specified either directly or as part of some other `valarray` or by a `slice_array`, `gslice_array`, `mask_array`, or `indirect_array`.|
-|[operator&#91;&#93;](#op_at)|Returns a reference to an element or its value at specified index or a specified subset.|
+|[`operator[]`](#op_at)|Returns a reference to an element or its value at specified index or a specified subset.|
 |[operator^=](#op_xor_eq)|Obtains the element-wise exclusive logical or operator ( `XOR`) of an array with either a specified valarray or a value of the element type.|
-|[operator&#124;=](#op_or_eq)|Obtains the bitwise `OR` of elements in an array either with the corresponding elements in a specified `valarray` or with a value of the element type.|
+|[`operator|=`](#op_or_eq)|Obtains the bitwise `OR` of elements in an array either with the corresponding elements in a specified `valarray` or with a value of the element type.|
 |[operator~](#op_dtor)|A unary operator that obtains the bitwise `NOT` values of each element in a `valarray`.|
 
 ## <a name="apply"></a> apply
@@ -1118,7 +1118,7 @@ The second member operator is the same as the first, but with an [Rvalue Referen
 
 The third member operator replaces each element of the controlled sequence with a copy of *val*.
 
-The remaining member operators replace those elements of the controlled sequence selected by their arguments, which are generated only by [operator&#91;&#93;](#op_at).
+The remaining member operators replace those elements of the controlled sequence selected by their arguments, which are generated only by [`operator[]`](#op_at).
 
 If the value of a member in the replacement controlled sequence depends on a member in the initial controlled sequence, the result is undefined.
 
diff --git a/docs/standard-library/vector-bool-class.md b/docs/standard-library/vector-bool-class.md
@@ -37,10 +37,10 @@ Operations that deal with the **`bool`** type correspond to values in the contai
 |-|-|
 |[flip](#flip)|Reverses all bits in the `vector<bool>`.|
 |[swap](#swap)|Exchanges the elements of two `vector<bool>`s.|
-|[operator&#91;&#93;](#op_at)|Returns a simulated reference to the `vector<bool>` element at a specified position.|
-|`at`|Functions the same as the unspecialized [vector](../standard-library/vector-class.md)::at function, except that it uses the proxy class [vector\<bool>::reference](#reference_class). Also see [operator&#91;&#93;](#op_at).|
-|`front`|Functions the same as the unspecialized [vector](../standard-library/vector-class.md)::front function, except that it uses the proxy class [vector\<bool>::reference](#reference_class). Also see [operator&#91;&#93;](#op_at).|
-|`back`|Functions the same as the unspecialized [vector](../standard-library/vector-class.md)::back function, except that it uses the proxy class [vector\<bool>::reference](#reference_class). Also see [operator&#91;&#93;](#op_at).|
+|[`operator[]`](#op_at)|Returns a simulated reference to the `vector<bool>` element at a specified position.|
+|`at`|Functions the same as the unspecialized [vector](../standard-library/vector-class.md)::at function, except that it uses the proxy class [vector\<bool>::reference](#reference_class). Also see [`operator[]`](#op_at).|
+|`front`|Functions the same as the unspecialized [vector](../standard-library/vector-class.md)::front function, except that it uses the proxy class [vector\<bool>::reference](#reference_class). Also see [`operator[]`](#op_at).|
+|`back`|Functions the same as the unspecialized [vector](../standard-library/vector-class.md)::back function, except that it uses the proxy class [vector\<bool>::reference](#reference_class). Also see [`operator[]`](#op_at).|
 
 ### Proxy Class
 
@@ -182,7 +182,7 @@ The `vector<bool>::reference` class is a proxy class provided by the [vector\<bo
 
 ### Remarks
 
-A simulated reference is required because C++ does not natively allow direct references to bits. `vector<bool>` uses only one bit per element, which can be referenced by using this proxy class. However, the reference simulation is not complete because certain assignments are not valid. For example, because the address of the `vector<bool>::reference` object cannot be taken, the following code that uses [vector\<bool>::operator&#91;&#93;](#op_at) is not correct:
+A simulated reference is required because C++ does not natively allow direct references to bits. `vector<bool>` uses only one bit per element, which can be referenced by using this proxy class. However, the reference simulation is not complete because certain assignments are not valid. For example, because the address of the `vector<bool>::reference` object cannot be taken, the following code that uses [`vector<bool>::operator[]`](#op_at) is not correct:
 
 ```cpp
 vector<bool> vb;
