Merge pull request #2648 from corob-msft/cr-1883

v-albemi · web-flow · commit 8744db43890b · 2020-01-28T12:08:01.000-08:00
Fix 1883 bad link
diff --git a/docs/cpp/constexpr-cpp.md b/docs/cpp/constexpr-cpp.md
@@ -1,40 +1,42 @@
 ---
 title: "constexpr (C++)"
-ms.date: "08/05/2019"
+description: "Guide to the C++ language constexpr keyword."
+ms.date: "01/28/2020"
 f1_keywords: ["constexpr_cpp"]
 ms.assetid: c6458ccb-51c6-4a16-aa61-f69e6f4e04f7
+no-loc: [constexpr, const, inline, goto, try, if, switch, for, while]
 ---
 # constexpr (C++)
 
-The keyword **constexpr** was introduced in C++11 and improved in C++14. It means *constant expression*. Like **const**, it can be applied to variables so that a compiler error is raised if any code attempts to modify the value. Unlike **const**, **constexpr** can also be applied to functions and class constructors. **constexpr** indicates that the value, or return value, is constant and, if possible, is computed at compile time.
+The keyword **constexpr** was introduced in C++11 and improved in C++14. It means *constant expression*. Like **const**, it can be applied to variables: A compiler error is raised when any code attempts to modify the value. Unlike **const**, **constexpr** can also be applied to functions and class constructors. **constexpr** indicates that the value, or return value, is constant and, where possible, is computed at compile time.
 
-A **constexpr** integral value can be used wherever a const integer is required, such as in template arguments and array declarations. And when a value can be computed at compile time instead of run time, it can help your program run faster and use less memory.
+A **constexpr** integral value can be used wherever a const integer is required, such as in template arguments and array declarations. And when a value is computed at compile time instead of run time, it helps your program run faster and use less memory.
 
 To limit the complexity of compile-time constant computations, and their potential impacts on compilation time, the C++14 standard requires the types in constant expressions to be [literal types](trivial-standard-layout-and-pod-types.md#literal_types).
 
 ## Syntax
 
-> **constexpr** *literal-type* *identifier* **=** *constant-expression* **;**
-> **constexpr** *literal-type* *identifier* **{** *constant-expression* **}** **;**
-> **constexpr** *literal-type* *identifier* **(** *params* **)** **;**
+> **constexpr** *literal-type* *identifier* **=** *constant-expression* **;**\
+> **constexpr** *literal-type* *identifier* **{** *constant-expression* **}** **;**\
+> **constexpr** *literal-type* *identifier* **(** *params* **)** **;**\
 > **constexpr** *ctor* **(** *params* **)** **;**
 
 ## Parameters
 
-*params*<br/>
+*params*\
 One or more parameters, each of which must be a literal type and must itself be a constant expression.
 
-## Return Value
+## Return value
 
-A constexpr variable or function must return a [literal type](trivial-standard-layout-and-pod-types.md#literal_types).
+A **constexpr** variable or function must return a [literal type](trivial-standard-layout-and-pod-types.md#literal_types).
 
 ## constexpr variables
 
-The primary difference between const and constexpr variables is that the initialization of a const variable can be deferred until run time. A constexpr variable must be initialized at compile time.  All constexpr variables are const.
+The primary difference between **const** and **constexpr** variables is that the initialization of a **const** variable can be deferred until run time. A **constexpr** variable must be initialized at compile time.  All **constexpr** variables are **const**.
 
-- A variable can be declared with **constexpr**, if it has a literal type and is initialized. If the initialization is performed by a constructor, the constructor must be declared as **constexpr**.
+- A variable can be declared with **constexpr**, when it has a literal type and is initialized. If the initialization is performed by a constructor, the constructor must be declared as **constexpr**.
 
-- A reference may be declared as constexpr if the object that it references has been initialized by a constant expression and any implicit conversions that are invoked during initialization are also constant expressions.
+- A reference may be declared as **constexpr** when both these conditions are met: The referenced object is initialized by a constant expression, and any implicit conversions invoked during initialization are also constant expressions.
 
 - All declarations of a **constexpr** variable or function must have the **constexpr** specifier.
 
@@ -49,7 +51,7 @@ constexpr int k = j + 1; //Error! j not a constant expression
 
 ## <a name="constexpr_functions"></a> constexpr functions
 
-A **constexpr** function is one whose return value can be computed at compile time when consuming code requires it. Consuming code requires the return value at compile time, for example, to initialize a **constexpr** variable or provide a non-type template argument. When its arguments are **constexpr** values, a **constexpr** function produces a compile-time constant. When called with non-**constexpr** arguments, or when its value isn't required at compile time, it produces a value at run time like a regular function. (This dual behavior saves you from having to write **constexpr** and non-**constexpr** versions of the same function.)
+A **constexpr** function is one whose return value is computable at compile time when consuming code requires it. Consuming code requires the return value at compile time to initialize a **constexpr** variable, or to provide a non-type template argument. When its arguments are **constexpr** values, a **constexpr** function produces a compile-time constant. When called with non-**constexpr** arguments, or when its value isn't required at compile time, it produces a value at run time like a regular function. (This dual behavior saves you from having to write **constexpr** and non-**constexpr** versions of the same function.)
 
 A **constexpr** function or constructor is implicitly **inline**.
 
@@ -59,23 +61,23 @@ The following rules apply to constexpr functions:
 
 - A **constexpr** function can be recursive.
 
-- It cannot be [virtual](../cpp/virtual-cpp.md). A constructor cannot be defined as constexpr if the enclosing class has any virtual base classes.
+- It can't be [virtual](../cpp/virtual-cpp.md). A constructor can't be defined as **constexpr** when the enclosing class has any virtual base classes.
 
 - The body can be defined as `= default` or `= delete`.
 
-- The body can contain no **goto** statements or try blocks.
+- The body can contain no **goto** statements or **try** blocks.
 
-- An explicit specialization of a non-constexpr template can be declared as **constexpr**:
+- An explicit specialization of a non-**constexpr** template can be declared as **constexpr**:
 
-- An explicit specialization of a **constexpr** template does not have to also be **constexpr**:
+- An explicit specialization of a **constexpr** template doesn't also have to be **constexpr**:
 
 The following rules apply to **constexpr** functions in Visual Studio 2017 and later:
 
-- It may contain **if** and **switch** statements, and all looping statements including **for**, range-based for, **while**, and **do-while**.
+- It may contain **if** and **switch** statements, and all looping statements including **for**, range-based **for**, **while**, and **do-while**.
 
-- It may contain local variable declarations, but the variable must be initialized, must be a literal type, and cannot be static or thread-local. The locally declared variable isn't required to be const and may mutate.
+- It may contain local variable declarations, but the variable must be initialized. It must be a literal type, and can't be **static** or thread-local. The locally declared variable isn't required to be **const**, and may mutate.
 
-- A constexpr non-static member function is not required to be implicitly const.
+- A **constexpr** non-**static** member function isn't required to be implicitly **const**.
 
 ```cpp
 constexpr float exp(float x, int n)
@@ -91,11 +93,11 @@ constexpr float exp(float x, int n)
 
 ## extern constexpr
 
-The [/Zc:externConstexpr](../build/reference/zc-externconstexpr.md) compiler option causes the compiler to apply [external linkage](../c-language/external-linkage.md) to variables declared by using **extern constexpr**. In earlier versions of Visual Studio, and by default or if **/Zc:externConstexpr-** is specified, Visual Studio applies internal linkage to **constexpr** variables even if the **extern** keyword is used. The **/Zc:externConstexpr** option is available starting in Visual Studio 2017 Update 15.6, and is off by default. The /permissive- option does not enable **/Zc:externConstexpr**.
+The [/Zc:externConstexpr](../build/reference/zc-externconstexpr.md) compiler option causes the compiler to apply [external linkage](../c-language/external-linkage.md) to variables declared by using **extern constexpr**. In earlier versions of Visual Studio, either by default or when **/Zc:externConstexpr-** is specified, Visual Studio applies internal linkage to **constexpr** variables even when the **extern** keyword is used. The **/Zc:externConstexpr** option is available starting in Visual Studio 2017 Update 15.6, and is off by default. The [/permissive-](../build/reference/permissive-standards-conformance.md) option doesn't enable **/Zc:externConstexpr**.
 
 ## Example
 
-The following example shows **constexpr** variables, functions, and a user-defined type. In the last statement in main(), the **constexpr** member function GetValue() is a run-time call because the value isn't required to be known at compile time.
+The following example shows **constexpr** variables, functions, and a user-defined type. In the last statement in `main()`, the **constexpr** member function `GetValue()` is a run-time call because the value isn't required to be known at compile time.
 
 ```cpp
 // constexpr.cpp
@@ -171,5 +173,5 @@ Visual Studio 2015 or later.
 
 ## See also
 
-[Declarations and Definitions](../cpp/declarations-and-definitions-cpp.md)\
+[Declarations and definitions](../cpp/declarations-and-definitions-cpp.md)\
 [const](../cpp/const-cpp.md)
diff --git a/docs/cpp/extern-cpp.md b/docs/cpp/extern-cpp.md
@@ -1,24 +1,29 @@
 ---
 title: "extern (C++)"
-ms.date: "04/12/2018"
+description: "Guide to the C++ language extern keyword."
+ms.date: "01/28/2020"
 f1_keywords: ["extern", "extern_CPP"]
 helpviewer_keywords: ["extern keyword [C++], linkage to non-C++ functions", "declarations, external", "external linkage, extern modifier"]
 ms.assetid: 1e2f0ae3-ae98-4410-85b5-222d6abc865a
+no-loc: [extern, const, constexpr, permissive]
 ---
 # extern (C++)
 
-The **extern** keyword is applied to a global variable, function or template declaration to specify that the name of that thing has *external linkage*. For background information on linkage and why the use of global variables is discouraged, see [Translation units and linkage](program-and-linkage-cpp.md).
+The **extern** keyword may be applied to a global variable, function, or template declaration. It specifies that the symbol has *external linkage*. For background information on linkage and why the use of global variables is discouraged, see [Translation units and linkage](program-and-linkage-cpp.md).
 
 The **extern** keyword has four meanings depending on the context:
 
-1. in a non-const global variable declaration, **extern** specifies that the variable or function is defined in another translation unit. The **extern** must be applied in all files except the one where the variable is defined.
-1. in a const variable declaration, it specifies that the variable has external linkage. The **extern** must be applied to all declarations in all files. (Global const variables have internal linkage by default.)
-1. **extern "C"** specifies that the function is defined elsewhere and uses the C-language calling convention. The extern "C" modifier may also be applied to multiple function declarations in a block.
-1. in a template declaration, it specifies that the template has already been instantiated elsewhere. This is an optimization that tells the compiler that it can re-use the other instantiation rather than creating a new one at the current location. For more information about this use of **extern**, see [Templates](templates-cpp.md).
+- In a non-**const** global variable declaration, **extern** specifies that the variable or function is defined in another translation unit. The **extern** must be applied in all files except the one where the variable is defined.
+
+- In a **const** variable declaration, it specifies that the variable has external linkage. The **extern** must be applied to all declarations in all files. (Global **const** variables have internal linkage by default.)
+
+- **extern "C"** specifies that the function is defined elsewhere and uses the C-language calling convention. The extern "C" modifier may also be applied to multiple function declarations in a block.
+
+- In a template declaration, **extern** specifies that the template has already been instantiated elsewhere. **extern** tells the compiler it can reuse the other instantiation, rather than create a new one at the current location. For more information about this use of **extern**, see [Explicit instantiation](explicit-instantiation.md).
 
 ## extern linkage for non-const globals
 
-When the linker sees **extern** before a global variable declaration, it looks for the definition in another translation unit. Declarations of non-const variables at global scope are external by default; only apply **extern** to the declarations that don't provide the definition.
+When the linker sees **extern** before a global variable declaration, it looks for the definition in another translation unit. Declarations of non-**const** variables at global scope are external by default. Only apply **extern** to the declarations that don't provide the definition.
 
 ```cpp
 //fileA.cpp
@@ -37,7 +42,7 @@ extern int i = 43; // same error (extern is ignored on definitions)
 
 ## extern linkage for const globals
 
-A **const** global variable has internal linkage by default. If you want the variable to have external linkage, apply the **extern** keyword to definition as well as to all other declarations in other files:
+A **const** global variable has internal linkage by default. If you want the variable to have external linkage, apply the **extern** keyword to the definition, and to all other declarations in other files:
 
 ```cpp
 //fileA.cpp
@@ -49,23 +54,23 @@ extern const int i;  // declaration only. same as i in FileA
 
 ## extern constexpr linkage
 
-In Visual Studio 2017 version 15.3 and earlier, the compiler always gave a constexpr variable internal linkage even when the variable was marked extern. In Visual Studio 2017 version 15.5, a new compiler switch ([/Zc:externConstexpr](../build/reference/zc-externconstexpr.md)) enables correct standards-conforming behavior. Eventually this will become the default. The /permissive- option does not enable /Zc:externConstexpr.
+In Visual Studio 2017 version 15.3 and earlier, the compiler always gave a **constexpr** variable internal linkage, even when the variable was marked **extern**. In Visual Studio 2017 version 15.5 and later, the [/Zc:externConstexpr](../build/reference/zc-externconstexpr.md) compiler switch enables correct standards-conforming behavior. Eventually the option will become the default. The [/permissive-](../build/reference/permissive-standards-conformance.md) option doesn't enable **/Zc:externConstexpr**.
 
 ```cpp
 extern constexpr int x = 10; //error LNK2005: "int const x" already defined
 ```
 
-If a header file contains a variable declared extern constexpr, it needs to be marked **__declspec(selectany)** in order to correctly have its duplicate declarations combined:
+If a header file contains a variable declared **extern** **constexpr**, it must be marked `__declspec(selectany)` to correctly have its duplicate declarations combined:
 
 ```cpp
 extern constexpr __declspec(selectany) int x = 10;
 ```
 
 ## extern "C" and extern "C++" function declarations
 
-In C++, when used with a string, **extern** specifies that the linkage conventions of another language are being used for the declarator(s). C functions and data can be accessed only if they are previously declared as having C linkage. However, they must be defined in a separately compiled translation unit.
+In C++, when used with a string, **extern** specifies that the linkage conventions of another language are being used for the declarator(s). C functions and data can be accessed only if they're previously declared as having C linkage. However, they must be defined in a separately compiled translation unit.
 
-Microsoft C++ supports the strings **"C"** and **"C++"** in the *string-literal* field. All of the standard include files use the **extern** "C" syntax to allow the run-time library functions to be used in C++ programs.
+Microsoft C++ supports the strings **"C"** and **"C++"** in the *string-literal* field. All of the standard include files use the **extern "C"** syntax to allow the run-time library functions to be used in C++ programs.
 
 ## Example
 
@@ -106,7 +111,7 @@ extern "C" char GetChar(void) {
 extern "C" int errno;
 ```
 
-If a function has more than one linkage specification, they must agree; it is an error to declare functions as having both C and C++ linkage. Furthermore, if two declarations for a function occur in a program — one with a linkage specification and one without — the declaration with the linkage specification must be first. Any redundant declarations of functions that already have linkage specification are given the linkage specified in the first declaration. For example:
+If a function has more than one linkage specification, they must agree. It's an error to declare functions as having both C and C++ linkage. Furthermore, if two declarations for a function occur in a program — one with a linkage specification and one without — the declaration with the linkage specification must be first. Any redundant declarations of functions that already have linkage specification are given the linkage specified in the first declaration. For example:
 
 ```cpp
 extern "C" int CFunc1();
@@ -123,8 +128,8 @@ extern "C" int CFunc2(); // Error: not the first declaration of
 
 ## See also
 
-[Keywords](../cpp/keywords-cpp.md)<br/>
-[Translation units and linkage](program-and-linkage-cpp.md)<br/>
-[extern Storage-Class Specifier in C](../c-language/extern-storage-class-specifier.md)<br/>
-[Behavior of Identifiers in C](../c-language/behavior-of-identifiers.md)<br/>
-[Linkage in C](../c-language/linkage.md)
+[Keywords](../cpp/keywords-cpp.md)\
+[Translation units and linkage](program-and-linkage-cpp.md)\
+[extern Storage-Class Specifier in C](../c-language/extern-storage-class-specifier.md)\
+[Behavior of Identifiers in C](../c-language/behavior-of-identifiers.md)\
+[Linkage in C](../c-language/linkage.md)
