more new 15.3 features and updates to conformance topic

Michael Blome · Michael Blome · commit dcd787d9b6bb · 2017-07-19T15:50:32.000-07:00
diff --git a/docs/cpp-conformance-improvements-2017.md b/docs/cpp-conformance-improvements-2017.md
diff --git a/docs/cpp/compound-statements-blocks.md b/docs/cpp/compound-statements-blocks.md
@@ -56,7 +56,9 @@ if( Amount > 100 )
     Alert();  
 }  
 else  
+{
     Balance -= Amount;  
+}
 ```  
   
 > [!NOTE]
diff --git a/docs/cpp/examples-of-lambda-expressions.md b/docs/cpp/examples-of-lambda-expressions.md
@@ -282,15 +282,26 @@ 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.
   
  You can use the `this` pointer explicitly in a function, as shown here:  
   
 ```cpp  
+
+// capture "this" by reference
 void ApplyScale(const vector<int>& v) const  
 {  
    for_each(v.begin(), v.end(),   
       [this](int n) { cout << n * _scale << endl; });  
 }  
+
+// capture "this" by value (Visual Studio 2017 version 15.3 and later)
+void ApplyScale2(const vector<int>& v) const  
+{  
+   for_each(v.begin(), v.end(),   
+      [*this](int n) { cout << n * _scale << endl; });  
+}  
+
 ```  
   
  You can also capture the `this` pointer implicitly:  
diff --git a/docs/cpp/if-else-statement-cpp.md b/docs/cpp/if-else-statement-cpp.md
@@ -47,6 +47,7 @@ else  // optional
    ...
 } 
 
+// Visual Studio 2017 version 15.3 and later:
 if ( initialization; expression )  
 {
    statement1;
@@ -57,6 +58,18 @@ else  // optional
    statement2;
    ...
 }  
+
+// Visual Studio 2017 version 15.3 and later:
+if constexpr (expression)
+{
+    statement1;
+    ...
+}
+else  // optional
+{
+   statement2;
+   ...
+} 
 ```  
 ## Example  
 ```  
@@ -105,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 initialization expression, as shown in the following example: 
+**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. 
 
 ```cpp
 ## Example  
@@ -143,18 +156,38 @@ int main()
 		shared_flag = false;
 	}
 
+
 	string s{ "if" };
-	if (auto keywords = { "if", "for", "while" }; any_of(keywords.begin(), keywords.end(), [&s](const char* kw) { return s == kw; }))
+    if (auto keywords = { "if", "for", "while" }; any_of(keywords.begin(), keywords.end(), [&s](const char* kw) { return s == kw; }))
 	{
 		cout << "Error! Token must not be a keyword\n";
 	}
 
 }
 ```
-## Remarks   
+
  In all forms of the **if** statement, *expression*, which can have any value except a structure, is evaluated, including all side effects. Control passes from the **if** statement to the next statement in the program unless one of the *statement*s contains a [break](../cpp/break-statement-cpp.md), [continue](../cpp/continue-statement-cpp.md), or [goto](../cpp/goto-statement-cpp.md).  
   
  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): 
+
+```cpp
+template <class T, class... Rest>
+void f(T&& t, Rest&&... r)
+{
+    // handle t
+	do_something(t);
+
+   constexpr if (sizeof...(r)) 
+   {
+      // handle r
+      f(r...); 
+   }
+}
+```
+
   
  
 ## See Also  
diff --git a/docs/cpp/lambda-expressions-in-cpp.md b/docs/cpp/lambda-expressions-in-cpp.md
@@ -1,7 +1,7 @@
 ---
 title: "Lambda Expressions in C++ | Microsoft Docs"
 ms.custom: ""
-ms.date: "11/04/2016"
+ms.date: "07/19/2017"
 ms.reviewer: ""
 ms.suite: ""
 ms.technology:  
@@ -35,8 +35,13 @@ translation.priority.ht:
   - "zh-tw"
 ---
 # Lambda Expressions in C++
-In C++11 and later, a lambda expression—often called a *lambda*—is a convenient way of defining an anonymous function object right at the location where it is invoked or passed as an argument to a function. Typically lambdas are used to encapsulate a few lines of code that are passed to algorithms or asynchronous methods. This article defines what lambdas are, compares them to other programming techniques, describes their advantages, and provides a basic example.  
-  
+In C++11 and later, a lambda expression—often called a *lambda*—is a convenient way of defining an anonymous function object (a *closure*) right at the location where it is invoked or passed as an argument to a function. Typically lambdas are used to encapsulate a few lines of code that are passed to algorithms or asynchronous methods. This article defines what lambdas are, compares them to other programming techniques, describes their advantages, and provides a basic example.  
+
+## Related Topics
+- [Lambda expressions vs. function objects](lambda-expression-syntax.md)
+- [Working with lambda expressions](examples-of-lambda-expressions.md)
+- [constexpr lambda expressions](lambda-expressions-constexpr.md)
+
 ## Parts of a Lambda Expression  
  The ISO C++ Standard shows a simple lambda that is passed as the third argument to the `std::sort()` function:  
   
@@ -95,10 +100,11 @@ void abssort(float* x, unsigned n) {
 struct S { void f(int i); };  
   
 void S::f(int i) {  
-    [&, i]{};    // OK  
-    [&, &i]{};   // ERROR: i preceded by & when & is the default  
-    [=, this]{}; // ERROR: this when = is the default  
-    [i, i]{};    // ERROR: i repeated  
+    [&, i]{};      // OK  
+    [&, &i]{};     // ERROR: i preceded by & when & is the default  
+    [=, this]{};   // ERROR: this when = is the default  
+    [=, *this]{ }; // OK: captures this by value. See below.
+    [i, i]{};      // ERROR: i repeated  
 }  
 ```  
   
@@ -112,7 +118,10 @@ 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. 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).  
+ 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. 
+
+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).  
   
  When you use the capture clause, we recommend that you keep these points in mind, particularly when you use lambdas with multithreading:  
   
@@ -325,6 +334,43 @@ 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.  
+
+```cpp
+    int y = 32;
+	auto answer = [y]() constexpr 
+	{
+		int x = 10;
+		return y + x; 
+	};
+
+    constexpr int Increment(int n) 
+    {
+	    return [n] { return n + 1; }();
+    }
+
+``` 
+A lambda is implicitly `constexpr` if its result satisfies the requirements of a `constexpr` function:
+```cpp
+	auto answer = [](int n) 
+	{
+		return 32 + n; 
+	};
+
+	constexpr int response = answer(10);
+``` 
+If a lambda is implicitly or explicitly `constexpr`, conversion to a function pointer produces a `constexpr` function:
+
+```cpp
+	auto Increment = [](int n)
+	{
+		return n + 1;
+	};
+
+	constexpr int(*inc)(int) = Increment;
+```
   
 ## Microsoft-Specific  
  Lambdas are not supported in the following common language runtime (CLR) managed entities: `ref class`, `ref struct`, `value class`, or `value struct`.  
diff --git a/docs/preprocessor/hash-if-hash-elif-hash-else-and-hash-endif-directives-c-cpp.md b/docs/preprocessor/hash-if-hash-elif-hash-else-and-hash-endif-directives-c-cpp.md
@@ -13,7 +13,8 @@ f1_keywords:
   - "#endif"
   - "#if"
   - "#elif"
-  - "Defined"
+  - "defined"
+  - "__has_include"
 dev_langs: 
   - "C++"
 helpviewer_keywords: 
@@ -111,7 +112,8 @@ The `#if` directive, with the `#elif`, `#else`, and `#endif` directives, control
 -   The translator can translate character constants to a set of code values different from the set for the target environment. To determine the properties of the target environment, check values of macros from LIMITS.H in an application built for the target environment.  
   
 -   The expression must not perform any environmental inquiries and must remain insulated from implementation details on the target computer.  
-  
+
+## defined  
  The preprocessor operator **defined** can be used in special constant expressions, as shown by the following syntax:  
   
  defined( `identifier` )  
@@ -190,6 +192,24 @@ class Example
 ```  
   
  The preceding code checks to see if the symbolic constant `EXAMPLE_H` is defined. If so, the file has already been included and need not be reprocessed. If not, the constant `EXAMPLE_H` is defined to mark EXAMPLE.H as already processed.  
+
+## __has_include
+**Visual Studio 2017 version 15.3 and later**:  Determines whether a library header is available for inclusion:  
+
+```cpp
+#ifdef __has_include
+#  if __has_include(<filesystem>)
+#    include <filesystem>
+#    define have_filesystem 1
+#  elif __has_include(<experimental/filesystem>)
+#    include <experimental/filesystem>
+#    define have_filesystem 1
+#    define experimental_filesystem
+#  else
+#    define have_filesystem 0
+#  endif
+#endif
+```
   
 ## See Also  
  [Preprocessor Directives](../preprocessor/preprocessor-directives.md)
diff --git a/docs/preprocessor/predefined-macros.md b/docs/preprocessor/predefined-macros.md
@@ -187,7 +187,7 @@ The Visual C++ compiler predefines certain preprocessor macros, depending on the
     ```  
   
 ## Standard predefined macros  
- The compiler supports these predefined macros specified by the ISO C99 and ISO C++14 standards.  
+ The compiler supports these predefined macros specified by the ISO C99 and ISO C++17 standards.  
   
 -   **__cplusplus** Defined as an integer literal value when the translation unit is compiled as C++. Otherwise, undefined.  
   

Original file line number	Diff line number	Diff line change
`@@ -56,7 +56,9 @@ if( Amount > 100 )`
`56`	`56`	`Alert();`
`57`	`57`	`}`
`58`	`58`	`else`
	`59`	`+{`
`59`	`60`	`Balance -= Amount;`
	`61`	`+}`
`60`	`62`	```
`61`	`63`
`62`	`64`	`> [!NOTE]`