@@ -166,7 +166,7 @@ When the packed unwind format is insufficient to describe the unwinding of a fun
    |0|20|*X* is a 1-bit field that indicates the presence (1) or absence (0) of exception data.|
    |0|21|*`E`* is a 1-bit field that indicates that information that describes a single epilogue is packed into the header (1) rather than requiring additional scope words later (0).|
    |0|22|*F* is a 1-bit field that indicates that this record describes a function fragment (1) or a full function (0). A fragment implies that there's no prologue and that all prologue processing should be ignored.|
-   |0|23-27|*Epilogue Count* is a 5-bit field that has two meanings, depending on the state of the *`E`* bit:<br /><br /> -   If *`E`* is 0, this field is a count of the total number of exception scopes described in section 3. If more than 31 scopes exist in the function, then this field and the *Code Words* field must both be set to 0 to indicate that an extension word is required.<br />-   If *`E`* is 1, this field specifies the index of the first unwind code that describes the only epilogue.|
+   |0|23-27|*Epilogue Count* is a 5-bit field that has two meanings, depending on the state of the *`E`* bit:<br /><br /> -   If *`E`* is 0, this field is a count of the total number of epilogue scopes described in section 2. If more than 31 scopes exist in the function, then this field and the *Code Words* field must both be set to 0 to indicate that an extension word is required.<br />-   If *`E`* is 1, this field specifies the index of the first unwind code that describes the only epilogue.|
    |0|28-31|*Code Words* is a 4-bit field that specifies the number of 32-bit words required to contain all of the unwind codes in section 4. If more than 15 words are required for more than 63 unwind code bytes, this field and the *Epilogue Count* field must both be set to 0 to indicate that an extension word is required.|
    |1|0-15|*Extended Epilogue Count* is a 16-bit field that provides more space for encoding an unusually large number of epilogues. The extension word that contains this field is only present if the *Epilogue Count* and *Code Words* fields in the first header word are both set to 0.|
    |1|16-23|*Extended Code Words* is an 8-bit field that provides more space for encoding an unusually large number of unwind code words. The extension word that contains this field is only present if the *Epilogue Count* and *Code Words* fields in the first header word are both set to 0.|
 
@@ -39,7 +39,7 @@ When you **open a folder** containing a *`CMakeLists.txt`* file, the following t
 - In the background, Visual Studio starts to index the source files to enable IntelliSense, browsing information, refactoring, and so on. As you work, Visual Studio monitors changes in the editor and also on disk to keep its index in sync with the sources.
 
 > [!NOTE]
-> Starting in Visual Studio 2022 version 17.1 Preview 2, if your folder doesn't contain a root `CMakeLists.txt` you'll be prompted whether you'd like to enable CMake integration or not. For more information, see [CMake partial activation](#cmake-partial-activation).
+> Starting in Visual Studio 2022 version 17.1 Preview 2, if your top-level `CMakeLists.txt` exists in a subfolder and not at the root of the workspace, you'll be prompted whether you'd like to enable CMake integration or not. For more information, see [CMake partial activation](#cmake-partial-activation).
 
 Once CMake cache generation has succeeded, you can also view your projects organized logically by targets. Choose the **Select View** button on the **Solution Explorer** toolbar. From the list in **Solution Explorer - Views**, select **CMake Targets View** and press **Enter** to open the targets view:
 
 
@@ -1,15 +1,15 @@
 ---
-description: "Learn more about: Exporting C Functions for Use in C or C++ Language Executables"
-title: "Exporting C Functions for Use in C or C++ Language Executables"
-ms.date: "11/04/2016"
+description: "Learn more about: Exporting C functions for use in C or C++ language executables"
+title: "Export C functions for use in C or C++ language executables"
+ms.date: 05/24/2022
 helpviewer_keywords: ["functions [C], exporting", "functions [C], C or C++ executables and", "__cplusplus macro", "exporting DLLs [C++], C functions in C++ executables", "exporting functions [C++], C functions in C++ executables"]
 ms.assetid: b51d6e5e-37cf-4c1c-b0bf-fcf188c82f00
 ---
-# Exporting C Functions for Use in C or C++ Language Executables
+# Export C functions for use in C or C++ language executables
 
-If you have functions in a DLL written in C that you want to access from a C language or C++ language module, you should use the **__cplusplus** preprocessor macro to determine which language is being compiled, and then declare these functions with C linkage if being used from a C++ language module. If you use this technique and provide header files for your DLL, these functions can be used by C and C++ users with no change.
+If you have functions in a DLL written in C, you can use a preprocessor macro to make them easy to access from both C language and C++ language code. The **`__cplusplus`** preprocessor macro indicates which language is being compiled. You may use it to declare the functions with C linkage when called from C++ language code. If you use this technique and provide header files for your DLL, these functions can be used by C and C++ users with no change.
 
-The following code shows a header file that can be used by C and C++ client applications:
+The following code shows a header file that both C and C++ client applications can use:
 
 ```h
 // MyCFuncs.h
@@ -26,7 +26,7 @@ __declspec( dllimport ) void AnotherCFunc();
 #endif
 ```
 
-If you need to link C functions to your C++ executable and the function declaration header files have not used the above technique, in the C++ source file, do the following to prevent the compiler from decorating the C function names:
+Sometimes you may need to link C functions to your C++ executable, but the function declaration header files haven't used the above technique. You can still call the functions from C++. In the C++ source file, wrap the `#include` directive to prevent the compiler from decorating the C function names:
 
 ```cpp
 extern "C" {
@@ -36,23 +36,23 @@ extern "C" {
 
 ## What do you want to do?
 
-- [Export from a DLL using .def files](exporting-from-a-dll-using-def-files.md)
+- [Export from a DLL using `.def` files](exporting-from-a-dll-using-def-files.md)
 
-- [Export from a DLL using __declspec(dllexport)](exporting-from-a-dll-using-declspec-dllexport.md)
+- [Export from a DLL using `__declspec(dllexport)`](exporting-from-a-dll-using-declspec-dllexport.md)
 
-- [Export and import using AFX_EXT_CLASS](exporting-and-importing-using-afx-ext-class.md)
+- [Export and import using `AFX_EXT_CLASS`](exporting-and-importing-using-afx-ext-class.md)
 
 - [Determine which exporting method to use](determining-which-exporting-method-to-use.md)
 
-- [Import into an application using __declspec(dllimport)](importing-into-an-application-using-declspec-dllimport.md)
+- [Import into an application using `__declspec(dllimport)`](importing-into-an-application-using-declspec-dllimport.md)
 
 - [Initialize a DLL](run-time-library-behavior.md#initializing-a-dll)
 
 ## What do you want to know more about?
 
 - [Decorated names](reference/decorated-names.md)
 
-- [Using extern to Specify Linkage](../cpp/extern-cpp.md)
+- [Using `extern` to specify linkage](../cpp/extern-cpp.md)
 
 ## See also
 
 
@@ -47,7 +47,7 @@ The function and class names are encoded in the decorated name. The rest of the
 
 ## <a name="FormatC"></a> Format of a C decorated name
 
-The form of decoration for a C function depends on the calling convention used in its declaration, as shown in the following table. This is also the decoration format that is used when C++ code is declared to have `extern "C"` linkage. The default calling convention is **`__cdecl`**. Note that in a 64-bit environment, functions are not decorated.
+The form of decoration for a C function depends on the calling convention used in its declaration, as shown in the following table. It's also the decoration format that's used when C++ code is declared to have `extern "C"` linkage. The default calling convention is **`__cdecl`**. In a 64-bit environment, C or `extern "C"` functions are only decorated when using the `__vectorcall` calling convention.
 
 |Calling convention|Decoration|
 |------------------------|----------------|
 
@@ -1,7 +1,7 @@
 ---
 description: "Learn more about: /showIncludes (List include files)"
 title: "/showIncludes (List include files)"
-ms.date: 04/15/2021
+ms.date: 05/24/2022
 f1_keywords: ["VC.Project.VCCLWCECompilerTool.ShowIncludes", "VC.Project.VCCLCompilerTool.ShowIncludes", "/showincludes"]
 helpviewer_keywords: ["include files", "/showIncludes compiler option [C++]", "include files, displaying in compilation", "-showIncludes compiler option [C++]", "showIncludes compiler option [C++]"]
 ---
@@ -30,8 +30,6 @@ Note: including file:  d:\temp\2.h
 
 In this case, *`2.h`* was included from within *`1.h`*, causing the indentation.
 
-The **`/showIncludes`** option emits to `stderr`, not `stdout`.
-
 ### To set this compiler option in the Visual Studio development environment
 
 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,35 +1,35 @@
 ---
 title: C26495
-ms.date: 03/22/2018
+ms.date: 05/23/2022
 ms.topic: reference
 f1_keywords: ["C26495"]
 helpviewer_keywords: ["C26495"]
 description: CppCoreCheck rule that enforces C++ Core Guidelines Type.6
 ---
 # C26495 MEMBER_UNINIT
 
-Variable '%variable%' is uninitialized. Always initialize a member variable (type.6).
+> Variable '*identifier*' is uninitialized. Always initialize a member variable (type.6).
 
-## See also
+## Remarks
 
-C++ Core Guidelines [Type.6](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#SS-type) and [C.48](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c48-prefer-in-class-initializers-to-member-initializers-in-constructors-for-constant-initializers)
+A member variable isn't initialized by a constructor or by an initializer. Make sure all variables are initialized by the end of construction. For more information, see C++ Core Guidelines [Type.6](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#SS-type) and [C.48](https://github.com/isocpp/CppCoreGuidelines/blob/master/CppCoreGuidelines.md#c48-prefer-in-class-initializers-to-member-initializers-in-constructors-for-constant-initializers).
 
 ## Example
 
 ```cpp
 struct MyStruct
 {
     int value;
-    MyStruct() {}; // C26495, MyStruct::value is uninitialized
+    MyStruct() {} // C26495, MyStruct::value is uninitialized
 };
 ```
 
-To fix the warning, add in-class initializers to all of the member variables. See the above linked C++ Core Guidelines pages for additional information.
+To fix the warning, add in-class initialization to all of the member variables:
 
 ```cpp
 struct MyStruct
 {
     int value{};
-    MyStruct() {}; // no warning, MyStruct::value is set via default member initialization
+    MyStruct() {} // no warning, MyStruct::value is set via default member initialization
 };
 ```
@@ -1,33 +1,31 @@
 ---
 description: "Learn more about: dllexport, dllimport"
 title: "dllexport, dllimport"
-ms.date: "11/04/2016"
+ms.date: 05/24/2022
 f1_keywords: ["dllimport_cpp", "dllexport_cpp"]
 helpviewer_keywords: ["dllexport __declspec keyword", "__declspec keyword [C++], dllexport", "dllimport __declspec keyword", "__declspec keyword [C++], dllimport"]
 ms.assetid: ff95b645-ef55-4e72-b848-df44657b3208
 ---
-# dllexport, dllimport
+# `dllexport`, `dllimport`
 
 **Microsoft Specific**
 
 The **`dllexport`** and **`dllimport`** storage-class attributes are Microsoft-specific extensions to the C and C++ languages. You can use them to export and import functions, data, and objects to or from a DLL.
 
 ## Syntax
 
-```
-   __declspec( dllimport ) declarator
-   __declspec( dllexport ) declarator
-```
+> **`__declspec( dllimport )`** *`declarator`*\
+> **`__declspec( dllexport )`** *`declarator`*
 
 ## Remarks
 
-These attributes explicitly define the DLL's interface to its client, which can be the executable file or another DLL. Declaring functions as **`dllexport`** eliminates the need for a module-definition (.def) file, at least with respect to the specification of exported functions. The **`dllexport`** attribute replaces the **__export** keyword.
+These attributes explicitly define the DLL's interface to its client, which can be the executable file or another DLL. Declaring functions as **`dllexport`** eliminates the need for a module-definition (`.def`) file, at least with respect to the specification of exported functions. The **`dllexport`** attribute replaces the **`__export`** keyword.
 
-If a class is marked declspec(dllexport), any specializations of class templates in the class hierarchy are implicitly marked as declspec(dllexport). This means that class templates are explicitly instantiated and the class's members must be defined.
+If a class is marked `__declspec(dllexport)`, any specializations of class templates in the class hierarchy are implicitly marked as `__declspec(dllexport)`. It means that class templates are explicitly instantiated and the class's members must be defined.
 
-**`dllexport`** of a function exposes the function with its decorated name. For C++ functions, this includes name mangling. For C functions or functions that are declared as `extern "C"`, this includes platform-specific decoration that's based on the calling convention. For information on name decoration in C/C++ code, see [Decorated Names](../build/reference/decorated-names.md). No name decoration is applied to exported C functions or C++ `extern "C"` functions using the **`__cdecl`** calling convention.
+**`dllexport`** of a function exposes the function with its decorated name, sometimes known as "name mangling". For C++ functions, the decorated name includes extra characters that encode type and parameter information. C functions or functions that are declared as `extern "C"` include platform-specific decoration that's based on the calling convention. No name decoration is applied to exported C functions or C++ `extern "C"` functions that use the **`__cdecl`** calling convention. For more information on name decoration in C/C++ code, see [Decorated names](../build/reference/decorated-names.md).
 
-To export an undecorated name, you can link by using a Module Definition (.def) file that defines the undecorated name in an EXPORTS section. For more information, see [EXPORTS](../build/reference/exports.md). Another way to export an undecorated name is to use a `#pragma comment(linker, "/export:alias=decorated_name")` directive in the source code.
+To export an undecorated name, you can link by using a Module Definition (`.def`) file that defines the undecorated name in an `EXPORTS` section. For more information, see [`EXPORTS`](../build/reference/exports.md). Another way to export an undecorated name is to use a `#pragma comment(linker, "/export:alias=decorated_name")` directive in the source code.
 
 When you declare **`dllexport`** or **`dllimport`**, you must use [extended attribute syntax](../cpp/declspec.md) and the **`__declspec`** keyword.
 
@@ -53,17 +51,17 @@ DllExport int n;
 
 For more information, see:
 
-- [Definitions and Declarations](../cpp/definitions-and-declarations-cpp.md)
+- [Definitions and declarations](../cpp/definitions-and-declarations-cpp.md)
 
-- [Defining Inline C++ Functions with dllexport and dllimport](../cpp/defining-inline-cpp-functions-with-dllexport-and-dllimport.md)
+- [Defining inline C++ functions with `dllexport` and `dllimport`](../cpp/defining-inline-cpp-functions-with-dllexport-and-dllimport.md)
 
-- [General Rules and Limitations](../cpp/general-rules-and-limitations.md)
+- [General rules and limitations](../cpp/general-rules-and-limitations.md)
 
-- [Using dllimport and dllexport in C++ Classes](../cpp/using-dllimport-and-dllexport-in-cpp-classes.md)
+- [Using `dllimport` and `dllexport` in C++ classes](../cpp/using-dllimport-and-dllexport-in-cpp-classes.md)
 
 **END Microsoft Specific**
 
 ## See also
 
-[__declspec](../cpp/declspec.md)<br/>
+[`__declspec`](../cpp/declspec.md)\
 [Keywords](../cpp/keywords-cpp.md)
@@ -142,7 +142,7 @@ Macros in C and C++ are tokens that are processed by the preprocessor before com
 constexpr int size = 10; // modern C++
 ```
 
-### Uniform initialization
+## Uniform initialization
 
 In modern C++, you can use brace initialization for any type. This form of initialization is especially convenient when initializing arrays, vectors, or other containers. In the following example, `v2` is initialized with three instances of `S`. `v3` is initialized with three instances of `S` that are themselves initialized using braces. The compiler infers the type of each element based on the declared type of `v3`.
 
 
@@ -1,20 +1,20 @@
 ---
 description: "Learn more about: Compiler Warning (level 1) C4273"
 title: "Compiler Warning (level 1) C4273"
-ms.date: "11/04/2016"
+ms.date: 05/23/2022
 f1_keywords: ["C4273"]
 helpviewer_keywords: ["C4273"]
 ms.assetid: cc18611d-9454-40a4-ad73-69823d5888fb
 ---
 # Compiler Warning (level 1) C4273
 
-'function' : inconsistent DLL linkage
+> '*function*' : inconsistent DLL linkage
 
-Two definitions in a file differ in their use of [dllimport](../../cpp/dllexport-dllimport.md).
+Two definitions in a file differ in their use of [`dllimport`](../../cpp/dllexport-dllimport.md).
 
 ## Examples
 
-The following sample generates C4273.
+The following sample generates C4273, and shows how to fix it.
 
 ```cpp
 // C4273.cpp
@@ -23,11 +23,16 @@ char __declspec(dllimport) c;
 char c;   // C4273, delete this line or the line above to resolve
 ```
 
-The following sample generates C4273.
+The following sample generates C4273. To fix it, delete the redeclaration of `printf_s`.
 
 ```cpp
 // C4273_b.cpp
 // compile with: /W1 /clr /c
 #include <stdio.h>
 extern "C" int printf_s(const char *, ...);   // C4273
 ```
+
+## See also
+
+[`dllexport`, `dllimport`](../../cpp/dllexport-dllimport.md)\
+[Export C functions for use in C or C++ language executables](../../build/exporting-c-functions-for-use-in-c-or-cpp-language-executables.md)