small edits

mikeblome · mikeblome · commit 32df055aa002 · 2017-08-02T09:59:53.000-07:00
diff --git a/docs/cpp/attributes2.md b/docs/cpp/attributes2.md
@@ -40,9 +40,9 @@ void Foo(int);
   
 -   `deprecated` - **Visual Studio 2015 and later:** Specifies that a function is not intended to be used, and might not exist in future versions of a library interface. The compiler can use this to generate an informational message when client code attempts to call the function. Can be applied to declaration of a class, a typedef-name, a variable, a non-static data member, a function, a namespace, an enumeration, an enumerator, or a template specialization.  
 
--   `[[fallthrough]]` - **Visual Studio 2017 and later:**(available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)) The `[[fallthrough]]` attribute can be used in the context of [switch](switch-statement-cpp.md) statements as a hint to the compiler (or anyone reading the code) that the fallthrough behavior is intended. The Visual C++ compiler currently does not warn on fallthrough behavior, so this attribute has no effect compiler behavior.
+-   `[[fallthrough]]` - **Visual Studio 2017 and later:** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)) The `[[fallthrough]]` attribute can be used in the context of [switch](switch-statement-cpp.md) statements as a hint to the compiler (or anyone reading the code) that the fallthrough behavior is intended. The Visual C++ compiler currently does not warn on fallthrough behavior, so this attribute has no effect compiler behavior.
 
-- `[[nodiscard]]` **Visual Studio 2017 version 15.3 and later:**(available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)) Specifies that a function's return value is not intended to be discarded. Raises warning C4834, as shown in the following example
+- `[[nodiscard]]` **Visual Studio 2017 version 15.3 and later:** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)) Specifies that a function's return value is not intended to be discarded. Raises warning C4834, as shown in the following example
  
 ```cpp
 [[nodiscard]]
@@ -55,7 +55,7 @@ int main()
 }
 ```
 
-- `[[maybe_unused]]` **Visual Studio 2017 version 15.3 and later:**(available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)) Specifies that a variable, function, class, typedef, non-static data member, enum, or template specialization may intentionally not be used. The compiler does not warn when an entity marked `[[maybe_unused]]` is not used. An entity that is declared without the attribute can later be redeclared with the attribute and vice versa. An entity is considered marked after its first declaration that is marked is analyzed, and for the remainder of translation of the current translation unit.
+- `[[maybe_unused]]` **Visual Studio 2017 version 15.3 and later:** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)) Specifies that a variable, function, class, typedef, non-static data member, enum, or template specialization may intentionally not be used. The compiler does not warn when an entity marked `[[maybe_unused]]` is not used. An entity that is declared without the attribute can later be redeclared with the attribute and vice versa. An entity is considered marked after its first declaration that is marked is analyzed, and for the remainder of translation of the current translation unit.
 
 ## Microsoft-specific attributes
   
diff --git a/docs/cpp/bool-cpp.md b/docs/cpp/bool-cpp.md
@@ -39,6 +39,8 @@ translation.priority.ht:
 ---
 # bool (C++)
 This keyword is a built-in type. A variable of this type can have values [true](../cpp/true-cpp.md) and [false](../cpp/false-cpp.md). Conditional expressions have the type `bool` and so have values of type `bool`. For example, `i!=0` now has **true** or **false** depending on the value of `i`.  
+
+**Visual Studio 2017 version 15.3 and later** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)): The operand of a postfix or prefix increment or decrement operator may not be of type `bool`. 
   
  The values **true** and **false** have the following relationship:  
   
@@ -55,8 +57,6 @@ if (condexpr1) statement1;
   
  If `condexpr1` is **true**, `statement1` is always executed; if `condexpr1` is **false**, `statement1` is never executed.  
   
- When a postfix or prefix `++` operator is applied to a variable of type `bool`, the variable is set to **true**. The postfix or prefix `--` operator cannot be applied to a variable of this type.  
-  
  The `bool` type participates in integral promotions. An r-value of type `bool` can be converted to an r-value of type `int`, with **false** becoming zero and **true** becoming one. As a distinct type, `bool` participates in overload resolution.  
   
 ## See Also  
diff --git a/docs/cpp/enumerations-cpp.md b/docs/cpp/enumerations-cpp.md
@@ -167,7 +167,7 @@ namespace ScopedEnumConversions
  Notice that the line `hand = account_num;` still causes the error that occurs with unscoped enums, as shown earlier. It is allowed with an explicit cast. However, with scoped enums, the attempted conversion in the next statement, `account_num = Suit::Hearts;`, is no longer allowed without an explicit cast. 
 
 ## Enums with no enumerators
-**Visual Studio 2017 version 15.3 and later**:By defining an enum (regular or scoped) with an explicit underlying type and no enumerators, you can in effect introduce a new integral type that has no implicit conversion to any other type. By using this type instead of its built-in underlying type, you can eliminate the potential for subtle errors caused by inadvertent implicit conversions.  
+**Visual Studio 2017 version 15.3 and later** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)): By defining an enum (regular or scoped) with an explicit underlying type and no enumerators, you can in effect introduce a new integral type that has no implicit conversion to any other type. By using this type instead of its built-in underlying type, you can eliminate the potential for subtle errors caused by inadvertent implicit conversions.  
 
 
 ```cpp
@@ -185,8 +185,8 @@ E e2 = E{ 0 };
 
 struct X 
 {
-	E e{ 0 };
-	X() : e{ 0 } { }
+    E e{ 0 };
+    X() : e{ 0 } { }
 };
 
 E* p = new E{ 0 }; 
@@ -195,12 +195,12 @@ void f(E e) {};
 
 int main()
 {
-	f(E{ 0 });
-	byte i{ 42 };
-	byte j = byte{ 42 };
+    f(E{ 0 });
+    byte i{ 42 };
+    byte j = byte{ 42 };
 
-	// unsigned char c = j; // C2440: 'initializing': cannot convert from 'byte' to 'unsigned char'
-  return 0;
+    // unsigned char c = j; // C2440: 'initializing': cannot convert from 'byte' to 'unsigned char'
+    return 0;
 }
 ``` 
   
diff --git a/docs/cpp/functions-cpp.md b/docs/cpp/functions-cpp.md
@@ -278,6 +278,7 @@ template<typename F, typename Tuple = tuple<T...>,
 ```  
 ## Returning multiple values from a function
 There are various ways to return more than one value from a function:
+
 1. Encapsulate the values in a named class or struct object. Requires the class or struct definition to be visible to the caller:
 
 ```cpp
@@ -288,25 +289,27 @@ using namespace std;
 
 struct S
 {
-	string name;
-	int num;
+    string name;
+    int num;
 };
 
 S g()
 {
-	string t{ "hello" };
-	int u{ 42 };
-	return { t, u };
+    string t{ "hello" };
+    int u{ 42 };
+    return { t, u };
 }
 
 int main()
 {
-	S s = g();
-	cout << s.name << " " << s.num << endl;
-	return 0;
+    S s = g();
+    cout << s.name << " " << s.num << endl;
+    return 0;
 }
 ```
+
 2. Return a std::tuple or std::pair object:
+
 ```cpp
 #include <tuple>
 #include <string>
@@ -317,30 +320,30 @@ using namespace std;
 
 tuple<int, string, double> f()
 {
-	int i{ 108 };
-	string s{ "Some text" };
-	double d{ .01 };
-	return { i,s,d };
+    int i{ 108 };
+    string s{ "Some text" };
+    double d{ .01 };
+    return { i,s,d };
 }
 
 int main()
 {
-	auto t = f();
-	cout << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << endl;
+    auto t = f();
+    cout << get<0>(t) << " " << get<1>(t) << " " << get<2>(t) << endl;
     
-	// --or--
+    // --or--
 
-	int myval;
-	string myname;
-	double mydecimal;
-	tie(myval, myname, mydecimal) = f();
-	cout << myval << " " << myname << " " << mydecimal << endl;
+    int myval;
+    string myname;
+    double mydecimal;
+    tie(myval, myname, mydecimal) = f();
+    cout << myval << " " << myname << " " << mydecimal << endl;
 
-	return 0;
+    return 0;
 }
 ```
 
-3. **Visual Studio 2017 version 15.3 and later** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)): Use structured bindings  The advantage of structured bindings is that the variables that store the return values are initialized at the same time they are declared, which in some cases can be significantly more efficient. In this statement --`auto[x, y, z] = f();`-- the brackets introduce and intialize names that are in scope for the entire function block.  
+3. **Visual Studio 2017 version 15.3 and later** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)): Use structured bindings. The advantage of structured bindings is that the variables that store the return values are initialized at the same time they are declared, which in some cases can be significantly more efficient. In this statement --`auto[x, y, z] = f();`-- the brackets introduce and intialize names that are in scope for the entire function block.  
 
 ```cpp
 #include <tuple>
@@ -351,36 +354,36 @@ using namespace std;
 
 tuple<int, string, double> f()
 {
-	int i{ 108 };
-	string s{ "Some text" };
-	double d{ .01 };
-	return { i,s,d };
+    int i{ 108 };
+    string s{ "Some text" };
+    double d{ .01 };
+    return { i,s,d };
 }
 struct S
 {
-	string name;
-	int num;
+    string name;
+    int num;
 };
 
 S g()
 {
-	string t{ "hello" };
-	int u{ 42 };
-	return { t, u };
+    string t{ "hello" };
+    int u{ 42 };
+    return { t, u };
 }
 
 int main()
 {
-	auto[x, y, z] = f(); // init from tuple
-	cout << x << " " << y << " " << z << endl;
+    auto[x, y, z] = f(); // init from tuple
+    cout << x << " " << y << " " << z << endl;
 
-	auto[a, b] = g(); // init from POD struct
-	cout << a << " " << b << endl;
-	return 0;
+    auto[a, b] = g(); // init from POD struct
+    cout << a << " " << b << endl;
+    return 0;
 }
 ```
 
-4. Although not "returning values" in the strict sense, you can define any number of parameters to use pass-by reference so that the function can modify or initialize the values of objects that the caller provides. For more information, see [Reference-Type Function Arguments](reference-type-function-arguments.md).
+4. In addition to using the return value itself, you can "return" values by defining any number of parameters to use pass-by-reference so that the function can modify or initialize the values of objects that the caller provides. For more information, see [Reference-Type Function Arguments](reference-type-function-arguments.md).
   
 ## Function pointers  
  C++ supports function pointers in the same manner as the C language. However a more type-safe alternative is usually to use a function object.  
diff --git a/docs/cpp/if-else-statement-cpp.md b/docs/cpp/if-else-statement-cpp.md
@@ -177,14 +177,19 @@ int main()
 template <class T, class... Rest>
 void f(T&& t, Rest&&... r)
 {
-    // handle t
-	do_something(t);
+// handle t
+   do_something(t);
 
+   // handle r conditionally
    constexpr if (sizeof...(r)) 
    {
-      // handle r
+      
       f(r...); 
    }
+   else
+   {
+       g(r...);
+   }
 }
 ```
 
diff --git a/docs/cpp/lambda-expressions-in-cpp.md b/docs/cpp/lambda-expressions-in-cpp.md
@@ -119,6 +119,7 @@ void f(Args... args) {
 ```  
   
  To use lambda expressions in the body of a class method, pass the `this` pointer to the capture clause to provide access to the methods and data members of the enclosing class. 
+ 
 **Visual Studio 2017 version 15.3 and later** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)): The `this` pointer may be captured by value by specifying `*this` in the capture clause. Capture by value means that the entire *closure*, which is the anonymous function object that encapulates the lambda expression, is copied to every call site where the lambda is invoked. Capture by value is useful when the lambda will execute in parallel or asynchronous operations, especially on certain hardware architectures such as NUMA. 
 
 For an example that shows how to use lambda expressions with class methods, see "Example: Using a Lambda Expression in a Method" in [Examples of Lambda Expressions](../cpp/examples-of-lambda-expressions.md).  
@@ -336,7 +337,7 @@ vector v after 2nd call to fillVector(): 10 11 12 13 14 15 16 17 18
  For more information, see [generate_n](../standard-library/algorithm-functions.md#generate_n).  
 
 ## constexpr lambda expressions
-**Visual Studio 2017 version 15.3 and later** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)): A lambda expression may be declared as `constexpr` or used in a contant expression when the initialization of each data member that it captures or introduces is allowed within a constant expression.  
+**Visual Studio 2017 version 15.3 and later** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)): A lambda expression may be declared as `constexpr` or used in a constant expression when the initialization of each data member that it captures or introduces is allowed within a constant expression.  
 
 ```cpp
     int y = 32;
diff --git a/docs/cpp/lvalues-and-rvalues-visual-cpp.md b/docs/cpp/lvalues-and-rvalues-visual-cpp.md
@@ -34,7 +34,7 @@ translation.priority.ht:
   - "zh-tw"
 ---
 # Lvalues and Rvalues (Visual C++)
-Every C++ expression has a type, and belongs to a *value category*. The value categories are the basis for rules that compilers must follow when creating, copying, and moving temporary objects during expression evaluation. In C++17 (**Visual Studio version 15.3 and later**) the rules were restated to ensure that all compilers behave identically by not creating objects unless they are actually required. The new specified behavior is called "guaranteed copy elision." It helps to make your code more portable and efficient and eliminates the need to provide copy and move constructors for types that never use them.
+Every C++ expression has a type, and belongs to a *value category*. The value categories are the basis for rules that compilers must follow when creating, copying, and moving temporary objects during expression evaluation. 
 
  The C++17 standard defines expression value categories as follows:
 
@@ -84,40 +84,6 @@ int main()
 > [!NOTE]
 >  The examples in this topic illustrate correct and incorrect usage when operators are not overloaded. By overloading operators, you can make an expression such as `j * 4` an lvalue.  
 
-The following example shows the new behavior for guaranteed copy elision. Note that construction from temporary objects succeeds in both cases despite the absence of a move constructor.
-
-```cpp
-#include <iostream>
-#include <string>
-
-using namespace std;
-
-struct S {
-	S(int) { cout << "S(int)" << endl; }
-	S(S&) = delete;
-	S(S&&) = delete; // { cout << "move" << endl; }
-	///...
-};
-
-S make_s() 
-{
-	// Return value initialized directly at call site.
-	// In Visual Studio 2015 this does not compile due to deleted move ctor.
-	return S(42);
-}
-
-
-int main()
-{
-	auto nm = make_s(); 
-	S x4 = 5; // Construct from an rvalue.
-}
-```
-The program produces this output:
-```output
-S(int)
-S(int)
-```
   
  The terms *lvalue* and *rvalue* are often used when you refer to object references. For more information about references, see [Lvalue Reference Declarator: &](../cpp/lvalue-reference-declarator-amp.md) and [Rvalue Reference Declarator: &&](../cpp/rvalue-reference-declarator-amp-amp.md).  
   

Original file line number	Diff line number	Diff line change
`@@ -177,14 +177,19 @@ int main()`
`177`	`177`	`template <class T, class... Rest>`
`178`	`178`	`void f(T&& t, Rest&&... r)`
`179`	`179`	`{`
`180`		`- // handle t`
`181`		`- do_something(t);`
	`180`	`+// handle t`
	`181`	`+ do_something(t);`
`182`	`182`
	`183`	`+ // handle r conditionally`
`183`	`184`	`constexpr if (sizeof...(r))`
`184`	`185`	`{`
`185`		`- // handle r`
	`186`	`+`
`186`	`187`	`f(r...);`
`187`	`188`	`}`
	`189`	`+ else`
	`190`	`+ {`
	`191`	`+ g(r...);`
	`192`	`+ }`
`188`	`193`	`}`
`189`	`194`	```
`190`	`195`