@@ -11,10 +11,11 @@ caps.latest.revision: 11
 manager: "ghogen"
 ---
 # Attributes in C++
- The C++ standard defines a set of attributes and also allows compiler vendors to define their own attributes (within a vendor-specific namespace), but compilers are required to recognize only those attributes defined in the standard. 
- In some cases, standard attributes overlap with compiler-specific declspec parameters. Visual C++, you can use the [[deprecated]] attribute instead of using declspec(deprecated) and the attribute will be recognized by any conformant compiler. For all other declspec parameters such as dllimport and dllexport, there is as yet no standard attribute equivalent so you must continue to use declspec syntax. Attributes do not affect the type system, and they don’t change the meaning of a program. Compilers ignore attribute values they don't recognize.
+ The C++ Standard defines a set of attributes and also allows compiler vendors to define their own attributes (within a vendor-specific namespace), but compilers are required to recognize only those attributes defined in the standard. 
 
-**Visual Studio 2017 version 15.3 and later:**(available with [/std:c++latest](../build/reference/std-specify-language-standard-version.md)) In the scope of an attribute list, you can specify the namespace for all names with a single `using` introducer:
+ In some cases, standard attributes overlap with compiler-specific declspec parameters. In Visual C++, you can use the `[[deprecated]]` attribute instead of using `declspec(deprecated)` and the attribute will be recognized by any conformant compiler. For all other declspec parameters such as dllimport and dllexport, there is as yet no attribute equivalent so you must continue to use declspec syntax. Attributes do not affect the type system, and they don’t change the meaning of a program. Compilers ignore attribute values they don't recognize.
+
+**Visual Studio 2017 version 15.3 and later**(available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)): In the scope of an attribute list, you can specify the namespace for all names with a single `using` introducer:
 
 ```cpp
 void g() {
@@ -39,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++latest](../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++latest](../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]]
@@ -54,7 +55,7 @@ int main()
 }
 ```
 
-- `[[maybe_unused]]` **Visual Studio 2017 version 15.3 and later:**(available with [/std:c++latest](../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
   
 
@@ -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:  
 
 
@@ -166,8 +166,8 @@ 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.  
+## Enums with no enumerators
+**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;
 }
 ``` 
 
 
@@ -282,7 +282,7 @@ int main()
 
 ### Example  
  You can use lambda expressions in the body of a function. The lambda expression can access any function or data member that the enclosing function can access. You can explicitly or implicitly capture the `this` pointer to provide access to functions and data members of the enclosing class.  
-**Visual Studio 2017 version 15.3 and later**: Capture `this` by value (`[*this]`) when the lambda will be used in asynchronous or parallel operations where the code might execute after the original object goes out of scope.
+**Visual Studio 2017 version 15.3 and later** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)): Capture `this` by value (`[*this]`) when the lambda will be used in asynchronous or parallel operations where the code might execute after the original object goes out of scope.
 
  You can use the `this` pointer explicitly in a function, as shown here:  
 
 
@@ -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,29 +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. Use structured bindings (**Visual Studio 2017 version 15.3 and later**): 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>
@@ -350,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.  
 
@@ -118,7 +118,7 @@ int main()
 }
 ```  
 ## if statement with an initializer
-**Visual Studio 2017 version 15.3 and later**: An **if** statement may also contain an expression that declares and initializes a named variable. Use this form of the if-statement when the variable is only needed within the scope of the if-block. 
+**Visual Studio 2017 version 15.3 and later** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)): An **if** statement may also contain an expression that declares and initializes a named variable. Use this form of the if-statement when the variable is only needed within the scope of the if-block. 
 
 ```cpp
 ## Example  
@@ -171,20 +171,25 @@ int main()
  The **else** clause of an `if...else` statement is associated with the closest previous **if** statement in the same scope that does not have a corresponding **else** statement.   
 
 ## constexpr if statements
-**Visual Studio 2017 version 15.3 and later**: In function templates, you can use a **constexpr if** statement to make compile-time branching decisions without having to resort to multiple function overloads. For example, you can write a single function that handles parameter unpacking (no zero-parameter overload is needed): 
+**Visual Studio 2017 version 15.3 and later** (available with [/std:c++17](../build/reference/std-specify-language-standard-version.md)): In function templates, you can use a **constexpr if** statement to make compile-time branching decisions without having to resort to multiple function overloads. For example, you can write a single function that handles parameter unpacking (no zero-parameter overload is needed): 
 
 ```cpp
 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...);
+   }
 }
 ```
 
 
@@ -19,7 +19,7 @@ ms.author: "mblome"
 manager: "ghogen"
 ---
 # constexpr Lambda Expressions in C++
-In Visual Studio 2017 version 15.3 and later, 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 contant expression when the initialization of each data member that it captures or introduces is allowed within a constant expression.  
 
 ```cpp
     int y = 32;
 
@@ -119,7 +119,8 @@ 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**: 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. 
+ 
+**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**: 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;