minor corrections

mtx48109 · mtx48109 · commit 74e4ac728c86 · 2018-07-09T13:15:24.000-07:00
diff --git a/docs/cpp/equality-operators-equal-equal-and-exclpt-equal.md b/docs/cpp/equality-operators-equal-equal-and-exclpt-equal.md
@@ -25,7 +25,7 @@ expression != expression
   
  The equality operators, equal to (`==`) and not equal to (`!=`), have lower precedence than the relational operators, but they behave similarly. The result type for these operators is **bool**.  
   
- The equal-to operator (`==`) returns TRUE (1) if both operands have the same value; otherwise, it returns FALSE (0). The not-equal-to operator (`!=`) returns TRUE if the operands do not have the same value; otherwise, it returns FALSE.  
+ The equal-to operator (`==`) returns **true** (1) if both operands have the same value; otherwise, it returns **false** (0). The not-equal-to operator (`!=`) returns **true** if the operands do not have the same value; otherwise, it returns **false**.  
   
 ## Operator Keyword for !=  
  The `not_eq` operator is the text equivalent of `!=`. There are two ways to access the `not_eq` operator in your programs: include the header file `iso646.h`, or compile with the [/Za](../build/reference/za-ze-disable-language-extensions.md) (Disable language extensions) compiler option.  
diff --git a/docs/cpp/event-handling-in-com.md b/docs/cpp/event-handling-in-com.md
@@ -142,9 +142,9 @@ MyHandler2 was called with value 123.
 ##  <a name="vcconeventhandlingincomanchorlayoutdependentcomevents"></a> Layout Dependent COM Events  
  Layout dependency is only an issue for COM programming. In native and managed event handling, the signatures (return type, calling convention, and arguments) of the handlers must match their events, but the handler names do not have to match their events.  
   
- However, in COM event handling, when you set the *layout_dependent* parameter of `event_receiver` to TRUE, the name and signature matching is enforced. This means that the names and signatures of the handlers in the event receiver must exactly match the names and signatures of the events to which they are hooked.  
+ However, in COM event handling, when you set the *layout_dependent* parameter of `event_receiver` to **true**, the name and signature matching is enforced. This means that the names and signatures of the handlers in the event receiver must exactly match the names and signatures of the events to which they are hooked.  
   
- When *layout_dependent* is set to FALSE, the calling convention and storage class (virtual, static, and so on) can be mixed and matched between the firing event method and the hooking methods (its delegates). It is slightly more efficient to have *layout_dependent*=TRUE.  
+ When *layout_dependent* is set to **false**, the calling convention and storage class (virtual, static, and so on) can be mixed and matched between the firing event method and the hooking methods (its delegates). It is slightly more efficient to have *layout_dependent*=**true**.  
   
  For example, suppose `IEventSource` is defined to have the following methods:  
   
diff --git a/docs/cpp/examples-of-lambda-expressions.md b/docs/cpp/examples-of-lambda-expressions.md
@@ -123,7 +123,7 @@ int main()
 ```  
   
 ### Example 2  
- This example passes a lambda expression as an argument to the `find_if` function. The lambda expression returns TRUE if its parameter is an even number.  
+ This example passes a lambda expression as an argument to the `find_if` function. The lambda expression returns **true** if its parameter is an even number.  
   
 ### Code  
   
diff --git a/docs/cpp/false-cpp.md b/docs/cpp/false-cpp.md
@@ -13,7 +13,7 @@ ms.author: "mblome"
 ms.workload: ["cplusplus"]
 ---
 # false (C++)
-The keyword is one of the two values for a variable of type [bool](../cpp/bool-cpp.md) or a conditional expression (a conditional expression is now a TRUE Boolean expression). For example, if `i` is a variable of type **bool**, the `i = false;` statement assigns FALSE to `i`.  
+The keyword is one of the two values for a variable of type [bool](../cpp/bool-cpp.md) or a conditional expression (a conditional expression is now a **true** Boolean expression). For example, if `i` is a variable of type **bool**, the `i = false;` statement assigns **false** to `i`.  
   
 ## Example  
   
diff --git a/docs/cpp/functions-cpp.md b/docs/cpp/functions-cpp.md
@@ -100,7 +100,7 @@ Optional parts of a function declaration are:
 
      For more information, see [Inline Functions](../cpp/inline-functions-cpp.md).
 
-1. A **noexcept** expression, which specifies whether or not the function can throw an exception. In the following example, the function does not throw an exception if the `is_pod` expression evaluates to TRUE.
+1. A **noexcept** expression, which specifies whether or not the function can throw an exception. In the following example, the function does not throw an exception if the `is_pod` expression evaluates to **true**.
 
     ```cpp
     #include <type_traits>
diff --git a/docs/cpp/fundamental-types-cpp.md b/docs/cpp/fundamental-types-cpp.md
@@ -29,17 +29,17 @@ Fundamental types in C++ are divided into three categories: integral, floating p
   
 |Category|Type|Contents|  
 |--------------|----------|--------------|  
-|Integral|**char**|Type **char** is an integral type that usually contains members of the basic execution character set — By default, this is ASCII in Microsoft C++.<br /><br /> The C++ compiler treats variables of type **char**, **signed** **char**, and **unsigned** **char** as having different types. Variables of type **char** are promoted to **int** as if they are type **signed** **char** by default, unless the /J compilation option is used. In this case they are treated as type **unsigned** **char** and are promoted to **int** without sign extension.|  
-||**bool**|Type **bool** is an integral type that can have one of the two values TRUE or FALSE. Its size is unspecified.|  
-||**short**|Type **short** **int** (or simply **short**) is an integral type that is larger than or equal to the size of type **char**, and shorter than or equal to the size of type **int**.<br /><br /> Objects of type **short** can be declared as **signed** **short** or **unsigned short**. **Signed short** is a synonym for **short**.|  
-||**int**|Type **int** is an integral type that is larger than or equal to the size of type **short** **int**, and shorter than or equal to the size of type **long**.<br /><br /> Objects of type **int** can be declared as **signed** **int** or **unsigned** **int**. **Signed** **int** is a synonym for **int**.|  
+|Integral|**char**|Type **char** is an integral type that usually contains members of the basic execution character set — By default, this is ASCII in Microsoft C++.<br /><br /> The C++ compiler treats variables of type **char**, **signed char**, and **unsigned char** as having different types. Variables of type **char** are promoted to **int** as if they are type **signed char** by default, unless the /J compilation option is used. In this case they are treated as type **unsigned char** and are promoted to **int** without sign extension.|  
+||**bool**|Type **bool** is an integral type that can have one of the two values **true** or **false**. Its size is unspecified.|  
+||**short**|Type **short int** (or simply **short**) is an integral type that is larger than or equal to the size of type **char**, and shorter than or equal to the size of type **int**.<br /><br /> Objects of type **short** can be declared as **signed short** or **unsigned short**. **Signed short** is a synonym for **short**.|  
+||**int**|Type **int** is an integral type that is larger than or equal to the size of type **short int**, and shorter than or equal to the size of type **long**.<br /><br /> Objects of type **int** can be declared as **signed int** or **unsigned int**. **Signed int** is a synonym for **int**.|  
 ||**__int8**, **__int16**, **__int32**, **__int64**|Sized integer `__int n`, where `n` is the size, in bits, of the integer variable. **__int8**, **__int16**, **__int32** and **__int64** are Microsoft-specific keywords. Not all types are available on all architectures. (**__int128** is not supported.)|  
-||**long**|Type **long** (or **long** **int**) is an integral type that is larger than or equal to the size of type **int**.<br /><br /> Objects of type **long** can be declared as **signed** **long** or **unsigned** **long**. **Signed** **long** is a synonym for **long**.|  
-||**long** **long**|Larger than an unsigned **long**.<br /><br /> Objects of type **long long** can be declared as **signed** **long long** or **unsigned** **long long**. **signed** **long long** is a synonym for **long long**.|  
+||**long**|Type **long** (or **long int**) is an integral type that is larger than or equal to the size of type **int**.<br /><br /> Objects of type **long** can be declared as **signed long** or **unsigned long**. **Signed long** is a synonym for **long**.|  
+||**long long**|Larger than an unsigned **long**.<br /><br /> Objects of type **long long** can be declared as **signed long long** or **unsigned long long**. **signed long long** is a synonym for **long long**.|  
 ||**wchar_t**, **__wchar_t**|A variable of type **wchar_t** designates a wide-character or multibyte character type. By default, **wchar_t** is a native type, but you can use [/Zc:wchar_t-](../build/reference/zc-wchar-t-wchar-t-is-native-type.md) to make **wchar_t** a typedef for **unsigned short**. The **__wchar_t** type is a Microsoft-specific synonym for the native **wchar_t** type.<br /><br /> Use the L prefix before a character or string literal to designate the wide-character type.|  
 |Floating point|**float**|Type **float** is the smallest floating point type.|  
-||**double**|Type **double** is a floating point type that is larger than or equal to type **float**, but shorter than or equal to the size of type **long** **double**.<br /><br /> Microsoft specific: The representation of **long double** and **double** is identical. However, **long double** and **double** are separate types.|  
-||**long double**|Type **long** **double** is a floating point type that is larger than or equal to type **double**.|  
+||**double**|Type **double** is a floating point type that is larger than or equal to type **float**, but shorter than or equal to the size of type **long double**.<br /><br /> Microsoft specific: The representation of **long double** and **double** is identical. However, **long double** and **double** are separate types.|  
+||**long double**|Type **long double** is a floating point type that is larger than or equal to type **double**.|  
   
  **Microsoft Specific**  
   
diff --git a/docs/cpp/goto-statement-cpp.md b/docs/cpp/goto-statement-cpp.md
@@ -28,7 +28,7 @@ goto identifier;
   
  It is good programming style to use the **break**, **continue**, and **return** statements instead of the **goto** statement whenever possible. However, because the **break** statement exits from only one level of a loop, you might have to use a **goto** statement to exit a deeply nested loop.  
   
- For more information about labels and the **goto** statement, see [Labeled Statements](../cpp/labeled-statements.md) and [Using Labels with the goto Statement](http://msdn.microsoft.com/en-us/6cd7c31a-9822-4241-8566-f79f51be48fe).  
+ For more information about labels and the **goto** statement, see [Labeled Statements](../cpp/labeled-statements.md) and [Using Labels with the goto Statement](http://msdn.microsoft.com/6cd7c31a-9822-4241-8566-f79f51be48fe).  
   
 ## Example  
  In this example, a **goto** statement transfers control to the point labeled `stop` when `i` equals 3.  
diff --git a/docs/cpp/hook.md b/docs/cpp/hook.md
@@ -42,7 +42,7 @@ long __hook(
 -   Managed events: *SourceClass* is the event source class and *EventMethod* is the event.  
   
  *interface*  
- The interface name being hooked to *receiver*, only for COM event receivers in which the *layout_dependent* parameter of the [event_receiver](../windows/event-receiver.md) attribute is TRUE.  
+ The interface name being hooked to *receiver*, only for COM event receivers in which the *layout_dependent* parameter of the [event_receiver](../windows/event-receiver.md) attribute is **true**.  
   
  *source*  
  A pointer to an instance of the event source. Depending on the code `type` specified in `event_receiver`, *source* can be one of the following:  
@@ -71,7 +71,7 @@ long __hook(
 ## Remarks  
  Use the intrinsic function **__hook** in an event receiver to associate or hook a handler method with an event method. The specified handler is then called when the source raises the specified event. You can hook several handlers to a single event or hook several events to a single handler.  
   
- There are two forms of **__hook**. You can use the first (four-argument) form in most cases, specifically, for COM event receivers in which the *layout_dependent* parameter of the [event_receiver](../windows/event-receiver.md) attribute is FALSE.  
+ There are two forms of **__hook**. You can use the first (four-argument) form in most cases, specifically, for COM event receivers in which the *layout_dependent* parameter of the [event_receiver](../windows/event-receiver.md) attribute is **false**.  
   
  In these cases you do not need to hook all methods in an interface before firing an event on one of the methods; only the method handling the event needs to be hooked. You can use the second (two-argument) form of **__hook** only for a COM event receiver in which *layout_dependent***=true**.  
   
