Merge branch 'mb-153' of github.com:MicrosoftDocs/cpp-docs-pr into mb-153

local merge

Author: mikeblome

docs/cpp-conformance-improvements-2017.md

@@ -231,6 +231,7 @@
 ## [Lambda Expressions in C++](lambda-expressions-in-cpp.md)
 ### [Lambda Expression Syntax](lambda-expression-syntax.md)
 ### [Examples of Lambda Expressions](examples-of-lambda-expressions.md)
+### [constexpr Lambda Expressions](lambda-expressions-constexpr.md)
 ## [Arrays (C++)](arrays-cpp.md)
 ### [Using Arrays (C++)](using-arrays-cpp.md)
 ### [Initializing Arrays](initializing-arrays.md)

docs/cpp/TOC.md

@@ -56,7 +56,9 @@ if( Amount > 100 )
     Alert();  
 }  
 else  
+{
     Balance -= Amount;  
+}
 ```  
 
 > [!NOTE]

docs/cpp/compound-statements-blocks.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:  

docs/cpp/examples-of-lambda-expressions.md

@@ -1,7 +1,7 @@
 ---
 title: "if-else Statement (C++) | Microsoft Docs"
 ms.custom: ""
-ms.date: "11/04/2016"
+ms.date: "07/17/2017"
 ms.reviewer: ""
 ms.suite: ""
 ms.technology:  
@@ -24,79 +24,172 @@ caps.latest.revision: 13
 author: "mikeblome"
 ms.author: "mblome"
 manager: "ghogen"
-translation.priority.ht: 
-  - "cs-cz"
-  - "de-de"
-  - "es-es"
-  - "fr-fr"
-  - "it-it"
-  - "ja-jp"
-  - "ko-kr"
-  - "pl-pl"
-  - "pt-br"
-  - "ru-ru"
-  - "tr-tr"
-  - "zh-cn"
-  - "zh-tw"
 ---
 # if-else Statement (C++)
-Controls conditional branching.  
+Controls conditional branching. Statements in the *if-block* are executed only if the *if-expression* evaluates to a non-zero value (or `true`). If the value of *expression* is nonzero, *statement1* and any other statements in the block are executed and the else-block, if present, is skipped. If the value of *expression* is zero, then the if-block is skipped and the else-block, if present, is executed. Expressions that evaluate to non-zero are
+- `true`
+- a non-null pointer,
+- any non-zero arithmetic value, or 
+- a class type that defines an unambiguous conversion to an arithmetic, boolean or pointer type. (For information about conversions, see [Standard Conversions](../cpp/standard-conversions.md).)   
 
 ## Syntax  
 
 ```  
+  
 if ( expression )  
-   statement1  
-[else  
-   statement2]  
+{
+   statement1;
+   ...  
+}
+else  // optional
+{
+   statement2;
+   ...
+} 
+
+// Visual Studio 2017 version 15.3 and later:
+if ( initialization; expression )  
+{
+   statement1;
+   ...  
+}
+else  // optional
+{
+   statement2;
+   ...
+}  
+
+// Visual Studio 2017 version 15.3 and later:
+if constexpr (expression)
+{
+    statement1;
+    ...
+}
+else  // optional
+{
+   statement2;
+   ...
+} 
 ```  
-  
-## Remarks  
- If the value of *expression* is nonzero, *statement1* is executed. If the optional **else** is present, *statement2* is executed if the value of *expression* is zero. *expression* must be of arithmetic or pointer type, or it must be of a class type that defines an unambiguous conversion to an arithmetic or pointer type. (For information about conversions, see [Standard Conversions](../cpp/standard-conversions.md).)  
-  
- In both 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.  
-  
- For this sample to be unambiguous about `if...else` pairing, uncomment the braces.  
-  
 ## Example  
-  
 ```  
 // if_else_statement.cpp  
-#include <stdio.h>  
-  
-int main()   
-{  
-   int x = 0;  
-   if (x == 0)  
-   {  
-      printf_s("x is 0!\n");  
-   }  
-   else  
-   {  
-      printf_s("x is not 0!\n"); // this statement will not be executed  
-   }  
-  
-   x = 1;  
-   if (x == 0)  
-   {  
-      printf_s("x is 0!\n"); // this statement will not be executed  
-   }  
-   else  
-   {  
-      printf_s("x is not 0!\n");  
-   }  
+#include <iostream>
+
+using namespace std;
+
+class C
+{
+    public:
+    void do_somthing(){}
+};
+void init(C){}
+bool is_true() { return true; }
+int x = 10;
+
+int main()
+{
+	if (is_true())
+	{
+		cout << "b is true!\n";  // executed
+	}
+	else
+	{
+		cout << "b is false!\n";
+	}
+
+  // no else statement
+	if (x == 10)
+	{
+		x = 0; 
+	}
+	
   
-   return 0;  
-}  
+	C* c;
+  init(c);
+	if (c)
+	{
+		c->do_something();
+	}
+	else
+	{
+		cout << "c is null!\n";
+	}
+}
 ```  
+## 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. 
+
+```cpp
+## Example  
+#include <iostream>
+#include <mutex>
+#include <map>
+#include <string>
+#include <algorithm>
+
+
+using namespace std;
+
+map<int, string> m;
+mutex mx;
+bool shared_flag; // guarded by mx
+void unsafe_operation() {}
+
+int main()
+{
+
+	if (auto it = m.find(10); it != m.end())
+	{
+		cout << it->second;
+		return 0;
+	}
+
+	if (char buf[10]; fgets(buf, 10, stdin))
+	{
+		m[0] += buf;
+	}
+
+	if (lock_guard<mutex> lock(mx); shared_flag)
+	{
+		unsafe_operation();
+		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; }))
+	{
+		cout << "Error! Token must not be a keyword\n";
+	}
+
+}
+```
+
+ 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).  
 
-```Output  
-x is 0!  
-x is not 0!  
-```  
+ 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  
  [Selection Statements](../cpp/selection-statements-cpp.md)   
  [Keywords](../cpp/keywords-cpp.md)   

docs/cpp/if-else-statement-cpp.md

@@ -0,0 +1,62 @@
+---
+title: "constexpr Lambda Expressions in C++ | Microsoft Docs"
+ms.custom: ""
+ms.date: "07/19/2017"
+ms.reviewer: ""
+ms.suite: ""
+ms.technology:  
+  - "cpp-language"
+ms.tgt_pltfrm: ""
+ms.topic: "language-reference"
+dev_langs: 
+  - "C++"
+helpviewer_keywords: 
+  - "lambda expressions [C++], constexpr"
+ms.assetid: b56346cd-fbff-475f-aeaa-ed2010c6d6f7
+caps.latest.revision: 0
+author: "mikeblome"
+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.  
+
+```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`, and you convert it to a function pointer, the resulting function is also `constexpr`:
+
+```cpp
+	auto Increment = [](int n)
+	{
+		return n + 1;
+	};
+
+	constexpr int(*inc)(int) = Increment;
+```
+  
+## See Also  
+ [C++ Language Reference](../cpp/cpp-language-reference.md)   
+ [Function Objects in the C++ Standard Library](../standard-library/function-objects-in-the-stl.md)   
+ [Function Call](../cpp/function-call-cpp.md)   
+ [for_each](../standard-library/algorithm-functions.md#for_each)