RomandevJavaScript
diff --git a/‎docs/build/reference/zc-char8-t.md‎
Lines changed: 40 additions & 0 deletions b/‎docs/build/reference/zc-char8-t.md‎
Lines changed: 40 additions & 0 deletions
diff --git a/‎docs/build/reference/zc-conformance.md‎
Lines changed: 1 addition & 0 deletions b/‎docs/build/reference/zc-conformance.md‎
Lines changed: 1 addition & 0 deletions
diff --git a/‎docs/build/toc.yml‎
Lines changed: 2 additions & 0 deletions b/‎docs/build/toc.yml‎
Lines changed: 2 additions & 0 deletions
diff --git a/‎docs/c-runtime-library/reference/get-errno.md‎
Lines changed: 7 additions & 7 deletions b/‎docs/c-runtime-library/reference/get-errno.md‎
Lines changed: 7 additions & 7 deletions
diff --git a/‎docs/cpp/member-access-control-cpp.md‎
Lines changed: 36 additions & 32 deletions b/‎docs/cpp/member-access-control-cpp.md‎
Lines changed: 36 additions & 32 deletions
@@ -0,0 +1,40 @@
+---
+description: "Learn more about the /Zc:char8_t (Enable C++20 char8_t type) compiler option."
+title: "/Zc:char8_t (Enable C++20 char8_t type)"
+ms.date: 08/11/2021
+f1_keywords: ["/Zc:char8_t"]
+helpviewer_keywords: ["-Zc:char8_t compiler option (C++)", "/Zc:char8_t compiler option (C++)"]
+---
+# `/Zc:char8_t` (Enable C++20 char8_t type)
+
+The **`/Zc:char8_t`** compiler option enables C++20 conforming **`char8_t`** type support. **`char8_t`** is a character type that's used to represent UTF-8 code units.
+
+## Syntax
+
+> **`/Zc:char8_t`**[**`-`**]
+
+## Remarks
+
+The **`/Zc:char8_t`** compiler option enables the **`char8_t`** type keyword as specified in the C++20 standard. It causes the compiler to generate `u8` prefixed character or string literals as `const char8_t` or `const char8_t[N]` types, respectively, instead of as `const char` or `const char[N]` types. In C++17, arrays of **`char`** may be initialized using `u8` string literals. In C++20, this initialization is ill-formed, and causes compiler error [C2440](../../error-messages/compiler-errors-1/compiler-error-c2440.md). This behavior can be a source-breaking change. You can revert the compiler to C++14 or C++17 behavior explicitly by specifying **`/Zc:char8_t-`**.
+
+The **`/Zc:char8_t`** option is available starting in Visual Studio 2019 version 16.1. It's enabled automatically when you specify [`/std:c++20`](std-specify-language-standard-version.md) or later (such as **`/std:c++latest`**). Otherwise, it's off by default.
+
+### Example
+
+```cpp
+const char* s = u8"Hello"; // Compiles in C++17, Error C2440 in C++20
+const char8_t* s = u8"Hello"; // Compiles in C++20 or with /Zc:char8_t
+```
+
+### To set this compiler option in Visual Studio
+
+1. Open the project's **Property Pages** dialog box. For details, see [Set C++ compiler and build properties in Visual Studio](../working-with-project-properties.md).
+
+1. Select the **Configuration Properties** > **C/C++** > **Command Line** property page.
+
+1. Add **`/Zc:char8_t`** or **`/Zc:char8_t-`** to the **Additional options:** pane.
+
+## See also
+
+[`/Zc` (Conformance)](zc-conformance.md)\
+[`/std` (Specify language standard version)](std-specify-language-standard-version.md)
@@ -24,6 +24,7 @@ Here are the **`/Zc`** compiler options:
 |--|--|
 | [`/Zc:alignedNew`](zc-alignednew.md) | Enable C++17 over-aligned dynamic allocation (on by default in C++17). |
 | [`/Zc:auto`](zc-auto-deduce-variable-type.md) | Enforce the new Standard C++ meaning for **`auto`** (on by default). |
+| [`/Zc:char8_t`](zc-char8-t.md) | Enable or disable C++20 native `u8` literal support as `const char8_t` (off by default, except under **`/std:c++20`**). |
 | [`/Zc:__cplusplus`](zc-cplusplus.md) | Enable the `__cplusplus` macro to report the supported standard (off by default). |
 | [`/Zc:externConstexpr`](zc-externconstexpr.md) | Enable external linkage for **`constexpr`** variables (off by default). |
 | [`/Zc:forScope`](zc-forscope-force-conformance-in-for-loop-scope.md) | Enforce Standard C++ **`for`** scoping rules (on by default). |
 
@@ -761,6 +761,8 @@
                       href: ../build/reference/zc-alignednew.md
                     - name: "/Zc:auto (Deduce variable type)"
                       href: ../build/reference/zc-auto-deduce-variable-type.md
+                    - name: "/Zc:char8_t (Enable C++20 char8_t type)"
+                      href: ../build/reference/zc-char8-t.md
                     - name: "/Zc:__cplusplus (Enable updated __cplusplus macro)"
                       href: ../build/reference/zc-cplusplus.md
                     - name: "/Zc:externConstexpr (Enable extern constexpr variables)"
 
@@ -41,20 +41,20 @@ By default, this function's global state is scoped to the application. To change
 
 ```C
 // crt_get_errno.c
-#include <stdio.h>
+#include <errno.h>
 #include <fcntl.h>
+#include <io.h>
+#include <stdio.h>
 #include <sys/stat.h>
-#include <share.h>
-#include <errno.h>
 
 int main()
 {
    errno_t err;
    int pfh;
-   _sopen_s( &pfh, "nonexistent.file", _O_WRONLY, _SH_DENYNO, _S_IWRITE );
-   _get_errno( &err );
-   printf( "errno = %d\n", err );
-   printf( "fyi, ENOENT = %d\n", ENOENT );
+   _sopen_s(&pfh, "nonexistent.file", _O_WRONLY, _SH_DENYNO, _S_IWRITE);
+   _get_errno(&err);
+   printf("errno = %d\n", err);
+   printf("fyi, ENOENT = %d\n", ENOENT);
 }
 ```
 
 
@@ -1,13 +1,14 @@
 ---
 description: "Learn more about: Member Access Control (C++)"
 title: "Member Access Control (C++)"
-ms.date: "11/19/2018"
+ms.date: 08/31/2021
 helpviewer_keywords: ["access control [C++]", "member access [C++]", "member-access control [C++]"]
+no-loc: ["public", "private", "protected"]
 ms.assetid: 2d596bca-56ad-4277-94e1-ce3db45fa14a
 ---
 # Member Access Control (C++)
 
-Access controls enable you to separate the [public](../cpp/public-cpp.md) interface of a class from the [private](../cpp/private-cpp.md) implementation details and the [protected](../cpp/protected-cpp.md) members that are only for use by derived classes. The access specifier applies to all members declared after it until the next access specifier is encountered.
+Access controls enable you to separate the [`public`](../cpp/public-cpp.md) interface of a class from the [`private`](../cpp/private-cpp.md) implementation details and the [`protected`](../cpp/protected-cpp.md) members that are only for use by derived classes. The access specifier applies to all members declared after it until the next access specifier is encountered.
 
 ```cpp
 class Point
@@ -27,17 +28,17 @@ protected:      // Declare protected function for derived classes only.
 };
 ```
 
-The default access is **`private`** in a class, and **`public`** in a struct or union. Access specifiers in a class can be used any number of times in any order. The allocation of storage for objects of class types is implementation dependent, but members are guaranteed to be assigned successively higher memory addresses between access specifiers.
+The default access is **`private`** in a class, and **`public`** in a struct or union. Access specifiers in a class can be used any number of times in any order. The allocation of storage for objects of class types is implementation-dependent. However, compilers must guarantee assignment of members to successively higher memory addresses between access specifiers.
 
 ## Member-Access Control
 
 |Type of Access|Meaning|
 |--------------------|-------------|
-|[private](../cpp/private-cpp.md)|Class members declared as **`private`** can be used only by member functions and friends (classes or functions) of the class.|
-|[protected](../cpp/protected-cpp.md)|Class members declared as **`protected`** can be used by member functions and friends (classes or functions) of the class. Additionally, they can be used by classes derived from the class.|
-|[public](../cpp/public-cpp.md)|Class members declared as **`public`** can be used by any function.|
+|[`private`](../cpp/private-cpp.md)|Class members declared as **`private`** can be used only by member functions and friends (classes or functions) of the class.|
+|[`protected`](../cpp/protected-cpp.md)|Class members declared as **`protected`** can be used by member functions and friends (classes or functions) of the class. Additionally, they can be used by classes derived from the class.|
+|[`public`](../cpp/public-cpp.md)|Class members declared as **`public`** can be used by any function.|
 
-Access control helps prevent you from using objects in ways they were not intended to be used. This protection is lost when explicit type conversions (casts) are performed.
+Access control helps prevent you from using objects in ways they weren't intended to be used. This protection is lost when you make explicit type conversions (casts).
 
 > [!NOTE]
 > Access control is equally applicable to all names: member functions, member data, nested classes, and enumerators.
@@ -54,13 +55,13 @@ The following table shows the interaction between these factors and how to deter
 
 ### Member Access in Base Class
 
-|private|protected|Public|
-|-------------|---------------|------------|
-|Always inaccessible regardless of derivation access|Private in derived class if you use private derivation|Private in derived class if you use private derivation|
-||Protected in derived class if you use protected derivation|Protected in derived class if you use protected derivation|
-||Protected in derived class if you use public derivation|Public in derived class if you use public derivation|
+| **`private`** | **`protected`** | **`public`** |
+|--|--|--|
+| Always inaccessible with any derivation access | **`private`** in derived class if you use **`private`** derivation | **`private`** in derived class if you use **`private`** derivation |
+|  | **`protected`** in derived class if you use **`protected`** derivation | **`protected`** in derived class if you use **`protected`** derivation |
+|  | **`protected`** in derived class if you use **`public`** derivation | **`public`** in derived class if you use **`public`** derivation |
 
-The following example illustrates this:
+The following example illustrates access derivation:
 
 ```cpp
 // access_specifiers_for_base_classes.cpp
@@ -104,11 +105,11 @@ int main()
 }
 ```
 
-In `DerivedClass1`, the member function `PublicFunc` is a public member and `ProtectedFunc` is a protected member because `BaseClass` is a public base class. `PrivateFunc` is private to `BaseClass`, and it is inaccessible to any derived classes.
+In `DerivedClass1`, the member function `PublicFunc` is a **`public`** member and `ProtectedFunc` is a **`protected`** member because `BaseClass` is a **`public`** base class. `PrivateFunc` is **`private`** to `BaseClass`, and it's inaccessible to any derived classes.
 
-In `DerivedClass2`, the functions `PublicFunc` and `ProtectedFunc` are considered private members because `BaseClass` is a private base class. Again, `PrivateFunc` is private to `BaseClass`, and it is inaccessible to any derived classes.
+In `DerivedClass2`, the functions `PublicFunc` and `ProtectedFunc` are considered **`private`** members because `BaseClass` is a **`private`** base class. Again, `PrivateFunc` is **`private`** to `BaseClass`, and it's inaccessible to any derived classes.
 
-You can declare a derived class without a base-class access specifier. In such a case, the derivation is considered private if the derived class declaration uses the **`class`** keyword. The derivation is considered public if the derived class declaration uses the **`struct`** keyword. For example, the following code:
+You can declare a derived class without a base-class access specifier. In such a case, the derivation is considered **`private`** if the derived class declaration uses the **`class`** keyword. The derivation is considered **`public`** if the derived class declaration uses the **`struct`** keyword. For example, the following code:
 
 ```cpp
 class Derived : Base
@@ -136,16 +137,16 @@ struct Derived : public Base
 ...
 ```
 
-Note that members declared as having private access are not accessible to functions or derived classes unless those functions or classes are declared using the **`friend`** declaration in the base class.
+Members declared as having **`private`** access aren't accessible to functions or derived classes unless those functions or classes are declared using the **`friend`** declaration in the base class.
 
-A **`union`** type cannot have a base class.
+A **`union`** type can't have a base class.
 
 > [!NOTE]
 > When specifying a private base class, it is advisable to explicitly use the **`private`** keyword so users of the derived class understand the member access.
 
 ## Access control and static members
 
-When you specify a base class as **`private`**, it affects only nonstatic members. Public static members are still accessible in the derived classes. However, accessing members of the base class using pointers, references, or objects can require a conversion, at which time access control is again applied. Consider the following example:
+When you specify a base class as **`private`**, it affects only nonstatic members. Public static members are still accessible in the derived classes. However, accessing members of the base class using pointers, references, or objects can require a conversion, which applies access control again. Consider the following example:
 
 ```cpp
 // access_control.cpp
@@ -160,34 +161,37 @@ public:
 class Derived1 : private Base
 {
 };
+
 // Derived2 declares Derived1 as a public base class.
 class Derived2 : public Derived1
 {
     int ShowCount();    // Nonstatic member.
 };
+
 // Define ShowCount function for Derived2.
 int Derived2::ShowCount()
 {
-   // Call static member function CountOf explicitly.
-    int cCount = Base::CountOf();     // OK.
-
-   // Call static member function CountOf using pointer.
-    cCount = this->CountOf();  // C2247. Conversion of
-                               //  Derived2 * to Base * not
-                               //  permitted.
+    // Call static member function CountOf explicitly.
+    int cCount = ::Base::CountOf();     // OK.
+
+    // Call static member function CountOf using pointer.
+    cCount = this->CountOf();  // C2247: 'Base::CountOf'
+                               // not accessible because
+                               // 'Derived1' uses 'private'
+                               // to inherit from 'Base'
     return cCount;
 }
 ```
 
-In the preceding code, access control prohibits conversion from a pointer to `Derived2` to a pointer to `Base`. The **`this`** pointer is implicitly of type `Derived2 *`. To select the `CountOf` function, **`this`** must be converted to type `Base *`. Such a conversion is not permitted because `Base` is a private indirect base class to `Derived2`. Conversion to a private base class type is acceptable only for pointers to immediate derived classes. Therefore, pointers of type `Derived1 *` can be converted to type `Base *`.
+In the preceding code, access control prohibits conversion from a pointer to `Derived2` to a pointer to `Base`. The **`this`** pointer is implicitly of type `Derived2 *`. To select the `CountOf` function, **`this`** must be converted to type `Base *`. Such a conversion isn't permitted because `Base` is a private indirect base class to `Derived2`. Conversion to a private base class type is acceptable only for pointers to immediate derived classes. That's why pointers of type `Derived1 *` can be converted to type `Base *`.
 
-Note that calling the `CountOf` function explicitly, without using a pointer, reference, or object to select it, implies no conversion. Therefore, the call is allowed.
+An explicit call to the `CountOf` function, without using a pointer, reference, or object to select it, implies no conversion. That's why the call is allowed.
 
 Members and friends of a derived class, `T`, can convert a pointer to `T` to a pointer to a private direct base class of `T`.
 
 ## Access to virtual functions
 
-The access control applied to [virtual](../cpp/virtual-cpp.md) functions is determined by the type used to make the function call. Overriding declarations of the function do not affect the access control for a given type. For example:
+The access control applied to [`virtual`](../cpp/virtual-cpp.md) functions is determined by the type used to make the function call. Overriding declarations of the function don't affect the access control for a given type. For example:
 
 ```cpp
 // access_to_virtual_functions.cpp
@@ -217,10 +221,10 @@ int main()
 }
 ```
 
-In the preceding example, calling the virtual function `GetState` using a pointer to type `VFuncBase` calls `VFuncDerived::GetState`, and `GetState` is treated as public. However, calling `GetState` using a pointer to type `VFuncDerived` is an access-control violation because `GetState` is declared private in class `VFuncDerived`.
+In the preceding example, calling the virtual function `GetState` using a pointer to type `VFuncBase` calls `VFuncDerived::GetState`, and `GetState` is treated as **`public`**. However, calling `GetState` using a pointer to type `VFuncDerived` is an access-control violation because `GetState` is declared **`private`** in class `VFuncDerived`.
 
 > [!CAUTION]
-> The virtual function `GetState` can be called using a pointer to the base class `VFuncBase`. This does not mean that the function called is the base-class version of that function.
+> The virtual function `GetState` can be called using a pointer to the base class `VFuncBase`. This doesn't mean that the function called is the base-class version of that function.
 
 ## Access control with multiple inheritance
 
@@ -229,7 +233,7 @@ In multiple-inheritance lattices involving virtual base classes, a given name ca
 ![Diagram showing access along the paths of an inheritance graph.](../cpp/media/vc38v91.gif "Access along paths of an inheritance graph") <br/>
 Access along paths of an inheritance graph
 
-In the figure, a name declared in class `VBase` is always reached through class `RightPath`. The right path is more accessible because `RightPath` declares `VBase` as a public base class, whereas `LeftPath` declares `VBase` as private.
+In the figure, a name declared in class `VBase` is always reached through class `RightPath`. The right path is more accessible because `RightPath` declares `VBase` as a **`public`** base class, while `LeftPath` declares `VBase` as **`private`**.
 
 ## See also