1769497, incorporated author feedback.

Author: john-par

docs/cpp/new-operator-cpp.md

@@ -63,7 +63,7 @@ Specifies type to be allocated; it can be either a built-in or user-defined type
 *initializer*<br/>
 Provides a value for the initialized object. Initializers cannot be specified for arrays. The **`new`** operator will create arrays of objects only if the class has a default constructor.
 
-## Example: Allocate character array and object
+## Example: Allocate and free a character array
 
 The following code example allocates a character array and an object of class `CName` and then frees them.
 

docs/cpp/overload-resolution-of-function-template-calls.md

@@ -8,7 +8,7 @@ ms.assetid: a2918748-2cbb-4fc6-a176-e256f120bee4
 
 A function template can overload nontemplate functions of the same name. In this scenario, function calls are resolved by first using template argument deduction to instantiate the function template with a unique specialization. If template argument deduction fails, the other function overloads are considered to resolve the call. These other overloads, also known as the candidate set, include nontemplate functions and other instantiated function templates. If template argument deduction succeeds, then the generated function is compared with the other functions to determine the best match, following the rules for overload resolution. For more information, see [Function Overloading](function-overloading.md).
 
-## Example: Nontemplate function is chosen
+## Example: Choose a nontemplate function
 
 If a nontemplate function is an equally good match to a template function, the nontemplate function is chosen (unless the template arguments were explicitly specified), as in the call `f(1, 1)` in the following example.
 

docs/cpp/static-assert.md

@@ -78,7 +78,7 @@ int main()
 
 In the following example, the **`static_assert`** declaration has block scope. The **`static_assert`** verifies that the size of the VMPage structure is equal to the virtual memory pagesize of the system.
 
-## Example: `static_assert` with block scope
+## Example: `static_assert` at block scope
 
 ```cpp
 #include <sys/param.h> // defines PAGESIZE

docs/error-messages/tool-errors/missing-function-body-or-variable.md

@@ -21,7 +21,7 @@ int main() {
 }
 ```
 
-## Example: Include class function implementation
+## Example: Call to an implemented function
 
 In C++, make sure that you include the implementation of a specific function for a class and not just a prototype in the class definition. If you are defining the class outside of the header file, be sure to include the class name before the function (`Classname::memberfunction`).
 

docs/parallel/concrt/how-to-use-a-message-block-filter.md

@@ -32,7 +32,7 @@ Because the `transformer` object receives only prime numbers, the `transformer`
 
 The `transformer` object now processes only those values that are prime. In the previous example, `transformer` object processes all messages. Therefore, the previous example must receive the same number of messages that it sends. This example uses the result of the [concurrency::send](reference/concurrency-namespace-functions.md#send) function to determine how many messages to receive from the `transformer` object. The `send` function returns **`true`** when the message buffer accepts the message and **`false`** when the message buffer rejects the message. Therefore, the number of times that the message buffer accepts the message matches the count of prime numbers.
 
-## Example: Complete message block filter code sample
+## Example: Finished message block filter code sample
 
 The following code shows the complete example. The example calls both the `count_primes` function and the `count_primes_filter` function.
 

docs/parallel/concrt/how-to-use-exception-handling-to-break-from-a-parallel-loop.md

@@ -40,7 +40,7 @@ The following example creates a `tree` object and searches it for several values
 
 This example uses the [concurrency::parallel_invoke](reference/concurrency-namespace-functions.md#parallel_invoke) algorithm to search for values in parallel. For more information about this algorithm, see [Parallel Algorithms](../../parallel/concrt/parallel-algorithms.md).
 
-## Example: Complete exception handling code sample
+## Example: Finished exception handling code sample
 
 The following complete example uses exception handling to search for values in a basic tree structure.
 

docs/parallel/concrt/how-to-use-parallel-containers-to-increase-efficiency.md

@@ -16,7 +16,7 @@ The following example shows the `is_prime` function, which determines whether an
 
 [!code-cpp[concrt-carmichael-primes#1](../../parallel/concrt/codesnippet/cpp/how-to-use-parallel-containers-to-increase-efficiency_1.cpp)]
 
-## Example: Compute Carmichael function
+## Example: Compute prime and Carmichael numbers
 
 The following example uses the `is_prime` and `is_carmichael` functions to compute the sets of prime and Carmichael numbers. The example uses the [concurrency::parallel_invoke](reference/concurrency-namespace-functions.md#parallel_invoke) and [concurrency::parallel_for](reference/concurrency-namespace-functions.md#parallel_for) algorithms to compute each set in parallel. For more information about parallel algorithms, see [Parallel Algorithms](../../parallel/concrt/parallel-algorithms.md).
 
@@ -40,7 +40,7 @@ This example prints the prime factors for each Carmichael number if that number
 
 [!code-cpp[concrt-carmichael-primes#4](../../parallel/concrt/codesnippet/cpp/how-to-use-parallel-containers-to-increase-efficiency_4.cpp)]
 
-## Example: Complete parallel container code sample
+## Example: Finished parallel container code sample
 
 The following code shows the complete example, which uses parallel containers to compute the prime factors of the Carmichael numbers.
 

docs/parallel/concrt/how-to-write-a-parallel-for-loop.md

@@ -22,7 +22,7 @@ The following example shows the `parallel_matrix_multiply` function, which uses
 
 This example parallelizes the outer loop only because it performs enough work to benefit from the overhead for parallel processing. If you parallelize the inner loop, you will not receive a gain in performance because the small amount of work that the inner loop performs does not overcome the overhead for parallel processing. Therefore, parallelizing the outer loop only is the best way to maximize the benefits of concurrency on most systems.
 
-## Example: Complete parallel_for loop code sample
+## Example: Finished parallel_for loop code sample
 
 The following more complete example compares the performance of the `matrix_multiply` function versus the `parallel_matrix_multiply` function.