cpp formatting review pr17

mtx48109 · mtx48109 · commit 6262becf2ab8 · 2018-07-31T14:16:02.000-07:00
diff --git a/docs/cpp/exception-handling-differences.md b/docs/cpp/exception-handling-differences.md
@@ -73,7 +73,6 @@ public:
       return nSE;  
    }  
 };  
-  
 ```  
   
  To use this class, you install a custom C exception translation function that is called by the internal exception handling mechanism each time a C exception is thrown. Within your translation function, you can throw any typed exception (perhaps an `SE_Exception` type, or a class type derived from `SE_Exception`) that can be caught by an appropriate matching C++ **catch** handler. The translation function can simply return, which indicates that it did not handle the exception. If the translation function itself raises a C exception, [terminate](../c-runtime-library/reference/terminate-crt.md) is called.  
@@ -136,5 +135,5 @@ Caught a __try exception with SE_Exception.
 nSE = 0xc0000094  
 ```  
   
-## See Also  
+## See also  
  [Mixing C (Structured) and C++ Exceptions](../cpp/mixing-c-structured-and-cpp-exceptions.md)
diff --git a/docs/cpp/exception-handling-in-visual-cpp.md b/docs/cpp/exception-handling-in-visual-cpp.md
@@ -36,5 +36,5 @@ An exception is an error condition, possibly outside the program's control, that
   
  For information about exception handling on x64 processors, see [Exception Handling (x64)](../build/exception-handling-x64.md).  
   
-## See Also  
+## See also  
  [C++ Language Reference](../cpp/cpp-language-reference.md)
diff --git a/docs/cpp/exception-specifications-throw-cpp.md b/docs/cpp/exception-specifications-throw-cpp.md
@@ -123,7 +123,6 @@ About to throw 1
 in handler
 ```
 
-## See Also
-
- [try, throw, and catch Statements (C++)](../cpp/try-throw-and-catch-statements-cpp.md) 
+## See also
+ [try, throw, and catch Statements (C++)](../cpp/try-throw-and-catch-statements-cpp.md)  
  [C++ Exception Handling](../cpp/cpp-exception-handling.md)
diff --git a/docs/cpp/exceptions-and-stack-unwinding-in-cpp.md b/docs/cpp/exceptions-and-stack-unwinding-in-cpp.md
@@ -105,5 +105,4 @@ int main()
     Exiting main.  
   
 */  
-  
 ```  
diff --git a/docs/cpp/exit-function.md b/docs/cpp/exit-function.md
@@ -13,16 +13,16 @@ ms.author: "mblome"
 ms.workload: ["cplusplus"]
 ---
 # exit Function
-The `exit` function, declared in the standard include file \<stdlib.h>, terminates a C++ program.  
+The **exit** function, declared in the standard include file \<stdlib.h>, terminates a C++ program.  
   
- The value supplied as an argument to `exit` is returned to the operating system as the program's return code or exit code. By convention, a return code of zero means that the program completed successfully.  
+ The value supplied as an argument to **exit** is returned to the operating system as the program's return code or exit code. By convention, a return code of zero means that the program completed successfully.  
   
 > [!NOTE]
 >  You can use the constants EXIT_FAILURE and EXIT_SUCCESS, defined in \<stdlib.h>, to indicate success or failure of your program.  
   
- Issuing a **return** statement from the `main` function is equivalent to calling the `exit` function with the return value as its argument.  
+ Issuing a **return** statement from the `main` function is equivalent to calling the **exit** function with the return value as its argument.  
   
  For more information, see [exit](../c-runtime-library/reference/exit-exit-exit.md) in the *Run-Time Library Reference*.  
   
-## See Also  
+## See also  
  [Program Termination](../cpp/program-termination.md)
diff --git a/docs/cpp/explicit-instantiation.md b/docs/cpp/explicit-instantiation.md
@@ -47,5 +47,5 @@ extern template MyStack<int, 6>::MyStack( void );
 > [!NOTE]
 >  The **extern** keyword in the specialization only applies to member functions defined outside of the body of the class. Functions defined inside the class declaration are considered inline functions and are always instantiated.  
   
-## See Also  
+## See also  
  [Function Templates](../cpp/function-templates.md)
diff --git a/docs/cpp/explicit-overrides-cpp.md b/docs/cpp/explicit-overrides-cpp.md
@@ -113,5 +113,5 @@ In CMyClass::IMyInt2::mf2()
 In CMyClass::IMyInt2::mf2(int)  
 ```  
   
-## See Also  
+## See also  
  [Inheritance](../cpp/inheritance-cpp.md)
diff --git a/docs/cpp/explicit-specialization-of-function-templates.md b/docs/cpp/explicit-specialization-of-function-templates.md
@@ -46,5 +46,5 @@ int main()
 }  
 ```  
   
-## See Also  
- [Function Templates](../cpp/function-templates.md)
+## See also  
+ [Function Templates](../cpp/function-templates.md)
diff --git a/docs/cpp/explicit-type-conversion-operator-parens.md b/docs/cpp/explicit-type-conversion-operator-parens.md
@@ -94,15 +94,12 @@ d = float( i );
  Explicit type conversions can also be specified using the "cast" syntax. The previous example, rewritten using the cast syntax, is:  
   
 ```cpp
-
 d = (float)i;  
-
 ```  
   
  Both cast and function-style conversions have the same results when converting from single values. However, in the function-style syntax, you can specify more than one argument for conversion. This difference is important for user-defined types. Consider a `Point` class and its conversions:  
   
 ```cpp
-
 struct Point  
 {  
     Point( short x, short y ) { _x = x; _y = y; }  
@@ -111,7 +108,6 @@ struct Point
 };  
 ...  
 Point pt = Point( 3, 10 );  
-
 ```
   
  The preceding example, which uses function-style conversion, shows how to convert two values (one for *x* and one for *y*) to the user-defined type `Point`.  
@@ -123,6 +119,6 @@ Point pt = Point( 3, 10 );
   
  Type definition within casts is illegal.  
   
-## See Also  
+## See also  
  [Postfix Expressions](../cpp/postfix-expressions.md)   
  [C++ Built-in Operators, Precedence and Associativity](../cpp/cpp-built-in-operators-precedence-and-associativity.md)
diff --git a/docs/cpp/explicitly-defaulted-and-deleted-functions.md b/docs/cpp/explicitly-defaulted-and-deleted-functions.md
@@ -136,5 +136,4 @@ template < typename T >
 void call_with_true_double_only(T) =delete; //prevent call through type promotion of any T to double from succeeding.  
   
 void call_with_true_double_only(double param) { return; } // also define for const double, double&, etc. as needed.  
-  
 ```
diff --git a/docs/cpp/expression-statement.md b/docs/cpp/expression-statement.md
@@ -25,5 +25,5 @@ Expression statements cause expressions to be evaluated. No transfer of control
 ## Remarks  
  All expressions in an expression statement are evaluated and all side effects are completed before the next statement is executed. The most common expression statements are assignments and function calls.  Since the expression is optional, a semicolon alone is considered an empty expression statement, referred to as the [null](../cpp/null-statement.md) statement.  
   
-## See Also  
+## See also  
  [Overview of C++ Statements](../cpp/overview-of-cpp-statements.md)
diff --git a/docs/cpp/expressions-cpp.md b/docs/cpp/expressions-cpp.md
@@ -51,5 +51,5 @@ This section describes C++ expressions. Expressions are sequences of operators a
     > [!NOTE]
     >  Operators for built-in types cannot be overloaded; their behavior is predefined.  
   
-## See Also  
+## See also  
  [C++ Language Reference](../cpp/cpp-language-reference.md)
diff --git a/docs/cpp/expressions-with-binary-operators.md b/docs/cpp/expressions-with-binary-operators.md
@@ -88,5 +88,5 @@ Binary operators act on two operands in an expression. The binary operators are:
   
 -   [Comma Operator](../cpp/comma-operator.md) (,)  
   
-## See Also  
+## See also  
  [Types of Expressions](../cpp/types-of-expressions.md)
diff --git a/docs/cpp/expressions-with-unary-operators.md b/docs/cpp/expressions-with-unary-operators.md
@@ -74,5 +74,5 @@ Unary operators act on only one operand in an expression. The unary operators ar
   
  The *allocation-expression* refers to the **new** operator. The *deallocation-expression* refers to the **delete** operator. For more information, see the links earlier in this topic.  
   
-## See Also  
+## See also  
  [Types of Expressions](../cpp/types-of-expressions.md)
diff --git a/docs/cpp/extension-restrict.md b/docs/cpp/extension-restrict.md
@@ -52,5 +52,5 @@ union z {
 };  
 ```  
   
-## See Also  
+## See also  
  [Keywords](../cpp/keywords-cpp.md)
diff --git a/docs/cpp/extern-cpp.md b/docs/cpp/extern-cpp.md
@@ -133,10 +133,9 @@ extern "C" int CFunc2(); // Error: not the first declaration of
                          //  specifier.
 ```
 
-## See Also
-
-- [Keywords](../cpp/keywords-cpp.md)
-- [Program and linkage](program-and-linkage-cpp.md)
-- [extern Storage-Class Specifier in C](../c-language/extern-storage-class-specifier.md) 
-- [Behavior of Identifiers in C](../c-language/behavior-of-identifiers.md) 
-- [Linkage in C](../c-language/linkage.md)
+## See also
+ [Keywords](../cpp/keywords-cpp.md)  
+ [Program and linkage](program-and-linkage-cpp.md)  
+ [extern Storage-Class Specifier in C](../c-language/extern-storage-class-specifier.md)  
+ [Behavior of Identifiers in C](../c-language/behavior-of-identifiers.md)  
+ [Linkage in C](../c-language/linkage.md)
diff --git a/docs/cpp/false-cpp.md b/docs/cpp/false-cpp.md
@@ -35,5 +35,5 @@ int main()
 0  
 ```  
   
-## See Also  
+## See also  
  [Keywords](../cpp/keywords-cpp.md)
diff --git a/docs/cpp/fastcall.md b/docs/cpp/fastcall.md
@@ -65,6 +65,6 @@ typedef BOOL (__fastcall *funcname_ptr)(void * arg1, const char * arg2, DWORD fl
   
 **END Microsoft Specific**  
   
-## See Also  
+## See also  
  [Argument Passing and Naming Conventions](../cpp/argument-passing-and-naming-conventions.md)   
- [Keywords](../cpp/keywords-cpp.md)
+ [Keywords](../cpp/keywords-cpp.md)
diff --git a/docs/cpp/final-specifier.md b/docs/cpp/final-specifier.md
@@ -18,7 +18,6 @@ You can use the **final** keyword to designate virtual functions that cannot be
 ## Syntax  
   
 ```  
-  
 function-declaration final;  
 class class-name final base-classes  
 ```  
@@ -59,6 +58,6 @@ class DerivedClass: public BaseClass // compiler error: BaseClass is
 };  
 ```  
   
-## See Also  
+## See also  
  [Keywords](../cpp/keywords-cpp.md)   
  [override Specifier](../cpp/override-specifier.md)
diff --git a/docs/cpp/floating-limits.md b/docs/cpp/floating-limits.md
@@ -39,5 +39,5 @@ ms.workload: ["cplusplus"]
   
 **END Microsoft Specific**  
   
-## See Also  
+## See also  
  [Integer Limits](../cpp/integer-limits.md)
diff --git a/docs/cpp/floating-point-coprocessor-and-calling-conventions.md b/docs/cpp/floating-point-coprocessor-and-calling-conventions.md
@@ -14,5 +14,5 @@ ms.workload: ["cplusplus"]
 # Floating Point Coprocessor and Calling Conventions
 If you are writing assembly routines for the floating point coprocessor, you must preserve the floating point control word and clean the coprocessor stack unless you are returning a **float** or **double** value (which your function should return in ST(0)).  
   
-## See Also  
+## See also  
  [Calling Conventions](../cpp/calling-conventions.md)
diff --git a/docs/cpp/for-statement-cpp.md b/docs/cpp/for-statement-cpp.md
@@ -127,9 +127,9 @@ for (int i = 0 ; i < 5 ; i++) {
   
  By default, under [/Ze](../build/reference/za-ze-disable-language-extensions.md), a variable declared in a **for** loop remains in scope until the **for** loop's enclosing scope ends.  
   
- [/Zc:forScope](../build/reference/zc-forscope-force-conformance-in-for-loop-scope.md) enables standard behavior of variables declared in for loops without needing to specify /Za.  
+ [/Zc:forScope](../build/reference/zc-forscope-force-conformance-in-for-loop-scope.md) enables standard behavior of variables declared in for loops without needing to specify `/Za`.  
   
- It is also possible to use the scoping differences of the **for** loop to redeclare variables under /Ze as follows:  
+ It is also possible to use the scoping differences of the **for** loop to redeclare variables under `/Ze` as follows:  
   
 ```cpp  
 // for_statement5.cpp  
@@ -143,7 +143,7 @@ int main(){
   
  This more closely mimics the standard behavior of a variable declared in a **for** loop, which requires variables declared in a **for** loop to go out of scope after the loop is done. When a variable is declared in a **for** loop, the compiler internally promotes it to a local variable in the **for** loop's enclosing scope even if there is already a local variable with the same name.  
   
-## See Also  
+## See also  
  [Iteration Statements](../cpp/iteration-statements-cpp.md)   
  [Keywords](../cpp/keywords-cpp.md)   
  [while Statement (C++)](../cpp/while-statement-cpp.md)   
diff --git a/docs/cpp/friend-cpp.md b/docs/cpp/friend-cpp.md
@@ -46,7 +46,7 @@ friend class F;
 friend F;  
 ```  
   
- The first form introduces a new class F if no existing class by that name was found in the innermost namespace.  **C++11**: The second form does not introduce a new class; it can be used when the class has already been declared, and it must be used when declaring a template type parameter or a typedef as a friend.  
+ The first form introduces a new class F if no existing class by that name was found in the innermost namespace. **C++11**: The second form does not introduce a new class; it can be used when the class has already been declared, and it must be used when declaring a template type parameter or a typedef as a friend.  
   
  Use `class friend F` when the referenced type has not yet been declared:  
   
@@ -231,5 +231,5 @@ Implications of friend Relationship
   
  Friend functions defined inside class declarations are not considered in the scope of the enclosing class; they are in file scope.  
   
-## See Also  
- [Keywords](../cpp/keywords-cpp.md)
+## See also  
+ [Keywords](../cpp/keywords-cpp.md)
diff --git a/docs/cpp/function-call-cpp.md b/docs/cpp/function-call-cpp.md
@@ -17,7 +17,6 @@ The function-call operator, invoked using parentheses, is a binary operator.
 ## Syntax  
   
 ```  
-  
 primary-expression ( expression-list )  
 ```  
   
@@ -76,5 +75,5 @@ int main()
 }  
 ```  
   
-## See Also  
+## See also  
  [Operator Overloading](../cpp/operator-overloading.md)
diff --git a/docs/cpp/function-call-operator-parens.md b/docs/cpp/function-call-operator-parens.md
@@ -166,7 +166,7 @@ int main() {
   
  Functions can be called recursively. For more information about function declarations, see [Functions](functions-cpp.md). Related material is in [Program and Linkage](../cpp/program-and-linkage-cpp.md).  
   
-## See Also  
+## See also  
  [Postfix Expressions](../cpp/postfix-expressions.md)   
  [C++ Built-in Operators, Precedence and Associativity](../cpp/cpp-built-in-operators-precedence-and-associativity.md)   
- [Function Call](../c-language/function-call-c.md)   
+ [Function Call](../c-language/function-call-c.md)   
diff --git a/docs/cpp/function-overloading.md b/docs/cpp/function-overloading.md
@@ -151,7 +151,7 @@ F1 = Add( F2, 23 );
   
  The preceding statement builds two sets:  
   
-|Set 1: Candidate Functions That Have First Argument of Type Fraction|Set 2: Candidate Functions Whose Second Argument Can Be Converted to Type int|  
+|Set 1: Candidate Functions That Have First Argument of Type Fraction|Set 2: Candidate Functions Whose Second Argument Can Be Converted to Type **int**|  
 |--------------------------------------------------------------------------|-----------------------------------------------------------------------------------|  
 |Variant 1|Variant 1 (**int** can be converted to **long** using a standard conversion)|  
 |Variant 3||  
@@ -166,7 +166,7 @@ F1 = Add( 3, 6 );
   
  The preceding function call builds the following sets:  
   
-|Set 1: Candidate Functions That Have First Argument of Type int|Set 2: Candidate Functions That Have Second Argument of Type int|  
+|Set 1: Candidate Functions That Have First Argument of Type **int**|Set 2: Candidate Functions That Have Second Argument of Type **int**|  
 |---------------------------------------------------------------------|----------------------------------------------------------------------|  
 |Variant 2 (**int** can be converted to **long** using a standard conversion)|Variant 1 (**int** can be converted to **long** using a standard conversion)|  
   
@@ -270,7 +270,7 @@ volatile Over&
   
 3.  Match using standard conversions. Any sequence not classified as an exact match or a match using promotions that contains only standard conversions and trivial conversions is classified as a match using standard conversions. Within this category, the following rules are applied:  
   
-    -   Conversion from a pointer to a derived class, to a pointer to a direct or indirect base class is preferable to converting to **void \*** or **const void \***.  
+    -   Conversion from a pointer to a derived class, to a pointer to a direct or indirect base class is preferable to converting to `void *` or `const void *`.  
   
     -   Conversion from a pointer to a derived class, to a pointer to a base class produces a better match the closer the base class is to a direct base class. Suppose the class hierarchy is as shown in the following figure.  
   
@@ -427,7 +427,6 @@ int main()
     auto v2 = C().get_data(); // get the original. prints "rvalue"
     return 0;
 }
-
 ```
   
 ## Restrictions on overloading  
@@ -454,7 +453,7 @@ int main()
     void Print( PSTR szToPrint );  
     ```  
   
-     The preceding two functions have identical argument lists. `PSTR` is a synonym for type **char \***. In member scope, this code generates an error.  
+     The preceding two functions have identical argument lists. `PSTR` is a synonym for type `char *`. In member scope, this code generates an error.  
   
 -   Enumerated types are distinct types and can be used to distinguish between overloaded functions.  
   
@@ -561,8 +560,5 @@ double Account::Deposit( double dAmount, char *szPassword )
 }  
 ```
 
-
-
-  
-## See Also  
+## See also  
  [Functions (C++)](../cpp/functions-cpp.md)
diff --git a/docs/cpp/function-template-instantiation.md b/docs/cpp/function-template-instantiation.md
@@ -34,5 +34,5 @@ int main()
 }  
 ```  
   
-## See Also  
- [Function Templates](../cpp/function-templates.md)
+## See also  
+ [Function Templates](../cpp/function-templates.md)
diff --git a/docs/cpp/function-templates.md b/docs/cpp/function-templates.md
@@ -54,8 +54,8 @@ int main(int j) {
   
  When the template argument is explicitly specified, normal implicit conversions are done to convert the function argument to the type of the corresponding function template parameters. In the above example, the compiler will convert `char j` to type **int**.  
   
-## See Also  
+## See also  
  [Templates](../cpp/templates-cpp.md)   
  [Function Template Instantiation](../cpp/function-template-instantiation.md)   
  [Explicit Instantiation](../cpp/explicit-instantiation.md)   
- [Explicit Specialization of Function Templates](../cpp/explicit-specialization-of-function-templates.md)
+ [Explicit Specialization of Function Templates](../cpp/explicit-specialization-of-function-templates.md)
diff --git a/docs/cpp/functions-cpp.md b/docs/cpp/functions-cpp.md
diff --git a/docs/cpp/fundamental-types-cpp.md b/docs/cpp/fundamental-types-cpp.md

-Original file line number
+Diff line change
     Exiting main.
 */
+-
 ```
Original file line number	Diff line number	Diff line change
`@@ -46,5 +46,5 @@ int main()`
`46`	`46`	`}`
`47`	`47`	```
`48`	`48`
`49`		`-## See Also`
`50`		`- [Function Templates](../cpp/function-templates.md)`
	`49`	`+## See also`
	`50`	`+ [Function Templates](../cpp/function-templates.md)`