You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: docs/cpp/constexpr-cpp.md
+49-23Lines changed: 49 additions & 23 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -34,12 +34,15 @@ translation.priority.ht:
34
34
- "zh-tw"
35
35
---
36
36
# constexpr (C++)
37
-
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 will be 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, will be 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 can run faster and use less memory.
37
+
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 will be 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, will be 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.
The primary difference between const and constexpr variables is that the initialization of a const variable can be deferred until run time whereas a constexpr variable must be initialized at compile time. All constexpr variables are const.
70
+
71
+
- 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`.
67
72
68
-
```
73
+
- 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.
74
+
75
+
- All declarations of a `constexpr` variable or function must have the `constexpr` specifier.
76
+
77
+
78
+
79
+
80
+
81
+
```cpp
69
82
constexpr float x = 42.0;
70
83
constexpr float y{108};
71
84
constexpr float z = exp(5, 3);
@@ -75,9 +88,38 @@ constexpr int k = j + 1; //Error! j not a constant expression
75
88
```
76
89
77
90
## constexpr functions
78
-
A `constexpr` function is one whose return value can be computed at compile when consuming code requires it. A `constexpr` function must accept and return only literal types. When its arguments are `constexpr` values, and consuming code requires the return value at compile time, for example to initialize a `constexpr` variable or provide a non-type template argument, it produces a compile-time constant. When called with non-`constexpr` arguments, or when its value is not 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.)
91
+
A `constexpr` function is one whose return value can be computed at compile when consuming code requires it. When its arguments are `constexpr` values, and consuming code requires the return value at compile time, for example to initialize a `constexpr` variable or provide a non-type template argument, it produces a compile-time constant. When called with non-`constexpr` arguments, or when its value is not 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.)
92
+
93
+
A `constexpr` function or constructor is implicitly `inline`.
94
+
95
+
The following rules apply to constexpr functions:
96
+
97
+
- A `constexpr` function must accept and return only literal types.
98
+
99
+
- A `constexpr` function can be recursive.
100
+
101
+
- It cannot be [virtual](../cpp/virtual-cpp.md). A a constructor cannot be defined as constexpr if the enclosing class has any virtual base classes.
102
+
103
+
- The body can be defined as `= default` or `= delete`.
104
+
105
+
- The body can contain no `goto` statements or try blocks.
106
+
107
+
- An explicit specialization of a non-constexpr template can be declared as `constexpr`:
108
+
109
+
- An explicit specialization of a `constexpr` template does not have to also be `constexpr`:
110
+
111
+
112
+
<!--conformance note-->
113
+
The following rules apply to constexpr functions in Visual Studio 2017 and later:
114
+
115
+
- It may contain if and switch statements, and all looping statements including for, range-based for, while, and do-while
116
+
117
+
- 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 is not required to be const and may mutate.
118
+
119
+
- A constexpr non-static member function is not required to be implicitly const.
120
+
79
121
80
-
```
122
+
```cpp
81
123
constexprfloatexp(float x, int n)
82
124
{
83
125
return n == 0 ? 1 :
@@ -89,23 +131,7 @@ constexpr float exp(float x, int n)
89
131
> [!TIP]
90
132
> Note: In the Visual Studio debugger, you can tell whether a `constexpr` function is being evaluated at compile time by putting a breakpoint inside it. If the breakpoint is hit, the function was called at run-time. If not, then the function was called at compile time.
91
133
92
-
## General constexpr rules
93
-
For a function, variable, constructor or static data member to be defined as `constexpr`, it must meet certain requirements:
94
-
95
-
- A `constexpr` function can be recursive. It cannot be [virtual](../cpp/virtual-cpp.md), and its return type and parameter types must all be literal types. The body can be defined as `= default` or `= delete`. Otherwise it must follow these rules: it contains no `goto` statements, try blocks, unitialized variables, or variable definitions that are not literal types, or that are static or thread-local. Additionally, a constructor cannot be defined as constexpr if the enclosing class has any virtual base classes.
96
-
97
-
- 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`.
98
-
99
-
- 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.
100
-
101
-
- All declarations of a `constexpr` variable or function must have the `constexpr` specifier.
102
-
103
-
- An explicit specialization of a non-constexpr template can be declared as `constexpr`:
104
-
105
-
- An explicit specialization of a `constexpr` template does not have to also be `constexpr`:
106
-
107
-
- A `constexpr` function or constructor is implicitly `inline`.
108
-
134
+
109
135
## Example
110
136
The following example shows `constexpr` variables, functions and a user-defined type. Note that in the last statement in main(), the `constexpr` member function GetValue() is a run-time call because the value is not required to be known at compile time.
111
137
@@ -182,4 +208,4 @@ int main()
182
208
183
209
## See Also
184
210
[Declarations and Definitions](../cpp/declarations-and-definitions-cpp.md)
Copy file name to clipboardExpand all lines: docs/cpp/initializers.md
+3-2Lines changed: 3 additions & 2 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -388,7 +388,8 @@ int main() {
388
388
389
389
- no virtual member functions
390
390
391
-
- no brace-or-equal initializers for non-static members
391
+
> [!NOTE]
392
+
> <!--conformance note-->In Visual Studio 2015 and earlier, an aggregate is not allowed to have brace-or-equal initializers for non-static members. This restriction was removed in the C++14 standard and implemented in Visual Studio 2017.
392
393
393
394
Aggregate initializers consist of a braced initialization list, with or without an equals sign, as in the following example:
394
395
@@ -435,7 +436,7 @@ myArr3: 8 9 10 0 0
435
436
```
436
437
437
438
> [!IMPORTANT]
438
-
> Array members that declared but not explicitly initialized during aggregate initialization are zero-initialized, as in `myArr3` above.
439
+
> Array members that are declared but not explicitly initialized during aggregate initialization are zero-initialized, as in `myArr3` above.
439
440
440
441
#### Initializing unions and structs
441
442
If a union does not have a constructor, you can initialize it with a single value (or with another instance of a union). The value is used to initialize the first non-static field. This is different from struct initialization, in which the first value in the initializer is used to initialize the first field, the second to initialize the second field, and so on. Compare the initialization of unions and structs in the following example:
Copy file name to clipboardExpand all lines: docs/cppcx/compiler-and-linker-options-c-cx.md
+1-1Lines changed: 1 addition & 1 deletion
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -24,7 +24,7 @@ An environment variable, C++/CX compiler options, and linker options support the
24
24
25
25
|Option|Description|
26
26
|------------|-----------------|
27
-
|[/ZW](../build/reference/zw-windows-runtime-compilation.md)<br /><br /> /ZW:nostdlib|Enables [!INCLUDE[wrt](../cppcx/includes/wrt-md.md)] language extensions.<br /><br /> The `nostdlib` parameter prevents the compiler from using the standard, predefined search path to find assembly and .winmd files.<br /><br /> The **/ZW** compiler option implicitly specifies the following compiler options:<br /><br /> - [/FI](../build/reference/fi-name-atlde.md) vccorlib.h, which forces inclusion of the vccorlib.h header file that defines many types that are required by the compiler.<br />- [/FU](../build/reference/fu-name-forced-hash-using-file.md) Windows.winmd, which forces inclusion of the Windows.winmd metadata file that's provided by the operating system and defines many types in the [!INCLUDE[wrt](../cppcx/includes/wrt-md.md)].<br />- **/FU** Platform.winmd, which forces inclusion of the Platform.winmd metadata file that's provided by the compiler and defines most types in the Platform family of namespaces.|
27
+
|[/ZW](../build/reference/zw-windows-runtime-compilation.md)<br /><br /> /ZW:nostdlib|Enables [!INCLUDE[wrt](../cppcx/includes/wrt-md.md)] language extensions.<br /><br /> The `nostdlib` parameter prevents the compiler from using the standard, predefined search path to find assembly and .winmd files.<br /><br /> The **/ZW** compiler option implicitly specifies the following compiler options:<br /><br /> - **/FI** vccorlib.h, which forces inclusion of the vccorlib.h header file that defines many types that are required by the compiler.<br />- [/FU](../build/reference/fu-name-forced-hash-using-file.md) Windows.winmd, which forces inclusion of the Windows.winmd metadata file that's provided by the operating system and defines many types in the [!INCLUDE[wrt](../cppcx/includes/wrt-md.md)].<br />- **/FU** Platform.winmd, which forces inclusion of the Platform.winmd metadata file that's provided by the compiler and defines most types in the Platform family of namespaces.|
28
28
|[/AI](../build/reference/ai-specify-metadata-directories.md)*dir*|Adds a directory, which is specified by the *dir* parameter, to the search path that the compiler uses to find assembly and .winmd files.|
29
29
|**/FU***file*|Forces the inclusion of the specified module, or .winmd file. That is, you don't have to specify `#using`*file* in your source code. The compiler automatically forces the inclusion of its own Windows metadata file, Platform.winmd.|
30
30
|/D "WINAPI_FAMILY=2"|Creates a definition that enables the use of a subset of the Win32 SDK that's compatible with the [!INCLUDE[wrt](../cppcx/includes/wrt-md.md)].|
Copy file name to clipboardExpand all lines: docs/cppcx/enums-c-cx.md
+2-2Lines changed: 2 additions & 2 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -18,9 +18,9 @@ manager: "ghogen"
18
18
C++/CX supports the `public enum class` keyword, which is analagous to a standard C++ `scoped enum`. When you use an enumerator that's declared by using the `public enum class` keyword, you must use the enumeration identifier to scope each enumerator value.
19
19
20
20
## Remarks
21
-
A `public enum class` that doesn't have an access specifier, such as `public`, is treated as a standard C++ [scoped enum](../cpp/enumerations.md).
21
+
A `public enum class` that doesn't have an access specifier, such as `public`, is treated as a standard C++ [scoped enum](../cpp/enumerations-cpp.md).
22
22
23
-
A `public enum class` or `public enum struct` declaration can have an underlying type of any integral type although the [!INCLUDE[wrt](../cppcx/includes/wrt-md.md)] itself requires that the type be int32, or uint32 for a flags enum. The following syntax describes the parts of an `public enum class` or `public enum struct`. For more information, see [enum class](../Topic/enum%20class%20%20\(C++%20Component%20Extensions\).md).
23
+
A `public enum class` or `public enum struct` declaration can have an underlying type of any integral type although the [!INCLUDE[wrt](../cppcx/includes/wrt-md.md)] itself requires that the type be int32, or uint32 for a flags enum. The following syntax describes the parts of an `public enum class` or `public enum struct`.
24
24
25
25
This example shows how to define a public enum class:
0 commit comments