Merge pull request MicrosoftDocs#5067 from MicrosoftDocs/main

PhilKang0704 · web-flow · commit c4eaa46e71a5 · 2023-10-18T01:26:22.000+08:00
10/17/2023 AM Publish
diff --git a/docs/build/reference/ifc-map.md b/docs/build/reference/ifc-map.md
@@ -1,30 +1,33 @@
 ---
 title: "/ifcMap"
 description: "Map named modules and header units to IFC files."
-ms.date: 10/13/2023
+ms.date: 10/16/2023
 author: "tylermsft"
 ms.author: "twhitney"
 f1_keywords: ["/ifcMap"]
 helpviewer_keywords: ["/ifcMap", "Specify named module and header unit mappings to IFC files."]
 ---
 # `/ifcMap`
 
-This switch tells the compiler where to find the [TOML](https://toml.io/en/) file that maps named modules and header units to their respective IFC (.ifc) files.
+This switch tells the compiler where to find the IFC reference map file, which maps references to named modules and header units to their corresponding IFC (`.ifc`) files.
 
 ## Syntax
 
 > **`/ifcMap`** *`filename`*
 
 ## Remarks
 
-The *`filename`* argument specifies a TOML (Tom's Obvious Minimal Language) file. The file can be relative to the compiler's working directory, or an absolute path.
-Multiple `/ifcMap` arguments can be provided to the compiler.
+The `*filename*` argument specifies the IFC reference map file. It can be relative to the compiler's working directory, or an absolute path.
 
-The TOML file can contain a mix of `[[module]]` and `[[header-unit]]` references. Syntax errors or unrecognized table names result in compiler error `C7696` (TOML parse error).
+You can provide multiple `/ifcMap` arguments to the compiler.
 
-### TOML for named modules
+The IFC reference map file format is a subset of the [TOML](https://toml.io/en/) file format. The IFC reference map file can contain a mix of `[[module]]` and `[[header-unit]]` references.
 
-The format of the TOML file must adhere to the following specification for named modules:
+Syntax errors or unrecognized table names result in compiler error `C7696` (TOML parse error).
+
+### Map named modules
+
+The format of the IFC reference map file for named modules is:
 
 ```
 # Using literal strings
@@ -38,17 +41,17 @@ name = "N"
 ifc = "C:\\modules\\N.ifc"
 ```
 
-This TOML file maps the named modules `'M'` and `'N'` to their respective IFC files. The equivalent [`/reference'](module-reference.md) is:
+This IFC reference map file maps the named modules `'M'` and `'N'` to their respective IFC files. The equivalent [`/reference'](module-reference.md) is:
 
 ```cmd
 /reference M=C:\modules\M.ifc /reference N=C:\modules\N.ifc
 ```
 
 For more information about what types of module names are valid for the `name` field, see [`/reference remarks`](module-reference.md#remarks).
 
-### TOML for header units
+### Map header units
 
-The format of the TOML for header units is:
+The format of the IFC reference map file for header units is:
 
 ```
 # Using literal strings
@@ -70,13 +73,13 @@ name = ["angle", "algorithm"]
 ifc = "C:\\header-units\\algorithm.ifc"
 ```
 
-The equivalent [`/headerUnit`](headerunit.md) for the previous TOML is:
+This IFC reference map file maps `"my-utility.h"` to `C:\header-units\my-utility.h.ifc`, and `<vector>` to `C:\header-units\vector.ifc`, and so on. The equivalent [`/headerUnit`](headerunit.md) is:
 
 ```cmd
 /headerUnit:quote my-utility=C:\header-units\my-utility.h.ifc /headerUnit:angle vector=C:\header-units\vector.ifc /headerUnit:quote my-engine.h=C:\header-units\my-engine.h.ifc /headerUnit:angle algorithm=C:\header-units\algorithm.ifc
 ```
 
-When `[[header-unit]]` is specified in the TOML, the compiler implicitly enables [`/Zc:preprocessor`](zc-preprocessor.md), just as it's implicitly enabled when [`/headerUnit`](headerunit.md) is used. For more information about the behavior of the 'angle' and 'quote' lookup methods, see the [/headerUnit remarks](headerunit.md#remarks).
+When `[[header-unit]]` is specified in an IFC reference map file, the compiler implicitly enables [`/Zc:preprocessor`](zc-preprocessor.md), just as it's implicitly enabled when [`/headerUnit`](headerunit.md) is used. For more information about the behavior of the `angle` and `quote` lookup methods, see [/headerUnit remarks](headerunit.md#remarks).
 
 ## See also
 
diff --git a/docs/cpp/if-else-statement-cpp.md b/docs/cpp/if-else-statement-cpp.md
@@ -1,20 +1,19 @@
 ---
 title: "if-else statement (C++)"
 description: "Use if-else, if-else with initializer, and if-constexpr statements to control conditional branching."
-ms.date: 10/02/2020
+ms.date: 10/16/2023
 f1_keywords: ["else_cpp", "if_cpp"]
 helpviewer_keywords: ["if keyword [C++]", "else keyword [C++]"]
-ms.assetid: f8c45cde-6bce-42ae-81db-426b3dbd4caa
 ---
 # if-else statement (C++)
 
-An if-else statement controls conditional branching. Statements in the *`if-branch`* are executed only if the *`condition`* evaluates to a non-zero value (or **`true`**). If the value of *`condition`* is nonzero, the following statement gets executed, and the statement following the optional **`else`** gets skipped. Otherwise, the following statement gets skipped, and if there's an **`else`** then the statement following the **`else`** gets executed.
+An if-else statement controls conditional branching. Statements in the *`if-branch`* are executed only if the *`condition`* evaluates to a nonzero value (or **`true`**). If the value of *`condition`* is nonzero, the following statement gets executed, and the statement following the optional **`else`** gets skipped. Otherwise, the following statement gets skipped, and if there's an **`else`** then the statement following the **`else`** gets executed.
 
-*`condition`* expressions that evaluate to non-zero are:
+*`condition`* expressions that evaluate to nonzero are:
 
 - **`true`**
 - a non-null pointer,
-- any non-zero arithmetic value, or
+- any nonzero 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
@@ -69,52 +68,54 @@ This sample code shows several **`if`** statements in use, both with and without
 
 using namespace std;
 
-class C
-{
-    public:
-    void do_something(){}
-};
-void init(C){}
-bool is_true() { return true; }
-int x = 10;
-
 int main()
 {
-    if (is_true())
+    int x = 10;
+
+    if (x < 11)
     {
-        cout << "b is true!\n";  // executed
+        cout << "x < 11 is true!\n";  // executed
     }
     else
     {
-        cout << "b is false!\n";
+        cout << "x < 11 is false!\n"; // not executed
     }
 
     // no else statement
-    if (x == 10)
+    bool flag = false;
+    if (flag == true)
     {
-        x = 0;
+        x = 100; // not executed
     }
 
-    C* c;
-    init(c);
-    if (c)
+    int *p = new int(25);
+    if (p)
     {
-        c->do_something();
+        cout << *p << "\n"; // outputs 25
     }
     else
     {
-        cout << "c is null!\n";
+        cout << "p is null!\n"; // executed if memory allocation fails
     }
 }
 ```
 
+Output:
+
+```output
+x < 11 is true!
+25
+```
+
 ## <a name="if_with_init"></a> if statement with an initializer
 
-Starting in C++17, an **`if`** statement may also contain an *`init-statement`* 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-statement. **Microsoft-specific**: This form is available starting in Visual Studio 2017 version 15.3, and requires at least the [`/std:c++17`](../build/reference/std-specify-language-standard-version.md) compiler option.
+Starting in C++17, an **`if`** statement might also contain an *`init-statement`* 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-statement. **Microsoft-specific**: This form is available starting in Visual Studio 2017 version 15.3, and requires at least the [`/std:c++17`](../build/reference/std-specify-language-standard-version.md) compiler option.
 
 ### Example
 
 ```cpp
+// Compile with /std:c++17
+
 #include <iostream>
 #include <mutex>
 #include <map>
@@ -123,28 +124,27 @@ Starting in C++17, an **`if`** statement may also contain an *`init-statement`*
 
 using namespace std;
 
-map<int, string> m;
+map<int, string> m{ {1, "one"}, {2, "two"}, {10,"ten"} };
 mutex mx;
-bool shared_flag; // guarded by mx
-void unsafe_operation() {}
+bool shared_flag = true; // guarded by mx
+int getValue() { return 42; }
 
 int main()
 {
 
     if (auto it = m.find(10); it != m.end())
     {
-        cout << it->second;
-        return 0;
+        cout << it->second << "\n";
     }
 
-    if (char buf[10]; fgets(buf, 10, stdin))
+    if (int x = getValue(); x == 42)
     {
-        m[0] += buf;
+        cout << "x is 42\n";
     }
 
     if (lock_guard<mutex> lock(mx); shared_flag)
     {
-        unsafe_operation();
+        cout << "setting shared_flag to false\n";
         shared_flag = false;
     }
 
@@ -156,31 +156,62 @@ int main()
 }
 ```
 
+Output:
+
+```Output
+ten
+x is 42
+setting shared_flag to false
+Error! Token must not be a keyword
+```
+
 ## <a name="if_constexpr"> if constexpr statements
 
 Starting in C++17, you can use an **`if constexpr`** statement in function templates to make compile-time branching decisions without having to resort to multiple function overloads. **Microsoft-specific**: This form is available starting in Visual Studio 2017 version 15.3, and requires at least the [`/std:c++17`](../build/reference/std-specify-language-standard-version.md) compiler option.
 
 ### Example
 
-This example shows how you can write a single function that handles parameter unpacking. No zero-parameter overload is needed:
+This example shows how you can conditionally compile a template based on the type sent to it:
 
 ```cpp
-template <class T, class... Rest>
-void f(T&& t, Rest&&... r)
-{
-    // handle t
-    do_something(t);
+// Compile with /std:c++17
+#include <iostream>
 
-    // handle r conditionally
-    if constexpr (sizeof...(r))
+template<typename T>
+auto Show(T t)
+{
+    //if (std::is_pointer_v<T>) // Show(a) results in compiler error for return *t. Show(b) results in compiler error for return t.
+    if constexpr (std::is_pointer_v<T>) // This statement goes away for Show(a)
     {
-        f(r...);
+        return *t;
     }
     else
     {
-        g(r...);
+        return t;
     }
 }
+
+int main()
+{
+    int a = 42;
+    int* pB = &a;
+
+    std::cout << Show(a) << "\n"; // prints "42"
+    std::cout << Show(pB) << "\n"; // prints "42"
+}
+```
+
+The **`if constexpr`** statement is evaluated at compile time, and the compiler only generates code for the **`if`** branch that matches the type of the argument sent to the function template. If you comment out the **`if constexpr`** statement and uncomment the **`if`** statement, the compiler generates code for both branches. That means you get an error:
+- If you call `ShowValue(a);` you get an error on `return *t` because `t` isn't a pointer, even though the **`if`** statement is false and the code is never executed. 
+- If you call `ShowValue(pB);` you get an error on `return t` because `t` is a pointer, even though the **`if`** statement is true and the code is never executed.
+ 
+Using `if constexpr` solves this problem because only the statement that matches the type of the argument sent to the function template is compiled.
+
+Output:
+
+```output
+42
+42
 ```
 
 ## See also
diff --git a/docs/error-messages/compiler-errors-2/compiler-error-c2534.md b/docs/error-messages/compiler-errors-2/compiler-error-c2534.md
@@ -10,17 +10,27 @@ ms.assetid: 481f9f54-5b51-4aa0-8eea-218f10807705
 
 'identifier' : constructor cannot return a value
 
-A constructor cannot return a value or have a return type (not even a **`void`** return type).
-
-This error may be fixed by removing the **`return`** statement from the constructor definition.
+A constructor cannot contain a **`return`** statement with an expression (even if the expression has type **`void`**). This differs from regular void-returning function where a return expression of type **`void`** is allowed. However, using the **`return`** statement without an expression is allowed for early returns in the constructor.
 
 The following sample generates C2534:
 
 ```cpp
 // C2534.cpp
+// compile with: /c
+void void_func() {}
+
 class A {
 public:
    int i;
-   A() { return i; }   // C2534
+   A() {
+      return i;   // C2534
+      return 123;   // C2534
+      return (void)0;   // C2534
+      return void_func();   // C2534
+
+      return;   // OK
+   }
 };
 ```
+
+The preceding errors may be fixed by removing the entire **`return`** statement or omitting the return expression if an early return is desired.
diff --git a/docs/intrinsics/sentinel-conversion-functions.md b/docs/intrinsics/sentinel-conversion-functions.md
@@ -1,7 +1,7 @@
 ---
 description: "Learn more about: Sentinel floating-point conversion functions"
 title: "Sentinel conversion functions"
-ms.date: 11/18/2021
+ms.date: 10/16/2023
 f1_keywords: ["intrin/_cvt_dtoi_sent", "intrin/_cvt_dtoll_sent", "intrin/_cvt_dtoui_sent", "intrin/_cvt_dtoull_sent", "intrin/_cvt_ftoi_sent", "intrin/_cvt_ftoll_sent", "intrin/_cvt_ftoui_sent", "intrin/_cvt_ftoull_sent"]
 helpviewer_keywords: ["_cvt_dtoi_sent", "_cvt_dtoll_sent", "_cvt_dtoui_sent", "_cvt_dtoull_sent", "_cvt_ftoi_sent", "_cvt_ftoll_sent", "_cvt_ftoui_sent", "_cvt_ftoull_sent"]
 ---
@@ -35,20 +35,20 @@ The integer-typed result of the conversion.
 
 ## Requirements
 
-**Header**: \<intrin.h>
+**Header**: `<intrin.h>`
 
 **Architecture**: x86, x64
 
 ## Remarks
 
-These intrinsics are floating-point to integral type conversion functions that use a *sentinel* strategy: They return the result value farthest from zero as a proxy sentinel value for NaN. Any invalid conversion returns this sentinel value. The specific sentinel value returned depends on the result type.
+These intrinsics are floating-point to integral type conversion functions that use a *sentinel* strategy: They return the result value farthest from zero as a proxy sentinel value for `NaN`. Any invalid conversion returns this sentinel value. The specific sentinel value returned depends on the result type.
 
 | Result type | Sentinel | *`<limits.h>`* constant |
 |--|--|
-| `int` | -2147483648 (0xFFFFFFFF) | `INT_MIN` |
+| `int` | -2147483648 (0x80000000) | `INT_MIN` |
 | `unsigned int` | 4294967295 (0xFFFFFFFF) | `UINT_MAX` |
-| `long long` | -9223372036854775808 (0xFFFFFFFF'FFFFFFFF) | `LLONG_MIN` |
-| `unsigned long long` | 18446744073709551615 (0xFFFFFFFF'FFFFFFFF) | `ULLONG_MAX` |
+| `long long` | -9223372036854775808 (0x8000000000000000) | `LLONG_MIN` |
+| `unsigned long long` | 18446744073709551615 (0xFFFFFFFFFFFFFFFF) | `ULLONG_MAX` |
 
 The sentinel conversion intrinsics are available starting in Visual Studio 2019 version 16.10.
 
