Merge pull request MicrosoftDocs#2505 from MicrosoftDocs/master637370854851282292

Repo sync for protected CLA branch

Author: Colin Robertson

docs/c-runtime-library/ansi-c-compliance.md

@@ -1,6 +1,8 @@
 ---
 title: "ANSI C Compliance"
+description: "An overview of Microsoft C runtime naming conventions for ANSI C compliance."
 ms.date: "11/04/2016"
+ms.topic: "conceptual"
 f1_keywords: ["Ansi"]
 helpviewer_keywords: ["underscores, leading", "compatibility [C++], ANSI C", "compliance with ANSI C", "conventions [C++], Microsoft extensions", "underscores", "naming conventions [C++], Microsoft library", "ANSI [C++], C standard", "Microsoft extensions naming conventions"]
 ms.assetid: 6be271bf-eecf-491a-a928-0ee2dd60e3b9

docs/c-runtime-library/backward-compatibility.md

@@ -1,6 +1,8 @@
 ---
 title: "Backward Compatibility"
+description: "How to use the Microsoft OLDNAMES.LIB library to map function names for backwards compatibility."
 ms.date: "11/04/2016"
+ms.topic: "conceptual"
 helpviewer_keywords: ["CRT, compatibility", "backward compatibility, C run-time libraries", "compatibility, C run-time libraries", "backward compatibility"]
 ms.assetid: cc3175cf-97fd-492f-b329-5791aea63090
 ---

docs/c-runtime-library/byte-and-wide-streams.md

@@ -1,6 +1,8 @@
 ---
 title: "Byte and Wide Streams"
+description: "An overview of byte streams in the Microsoft C runtime library."
 ms.date: "11/04/2016"
+ms.topic: "conceptual"
 f1_keywords: ["Byte and Wide Streams"]
 helpviewer_keywords: ["byte streams", "wide streams"]
 ms.assetid: 61ef0587-4cbc-4eb8-aae5-4c298dbbc6f9

docs/c-runtime-library/c-run-time-library-reference.md

@@ -1,5 +1,6 @@
 ---
 title: "C Run-Time Library Reference"
+description: "Links to information and reference for the Microsoft C runtime library functions."
 ms.date: "11/04/2016"
 f1_keywords: ["c.runtime"]
 helpviewer_keywords: ["CRT", "run-time libraries", "CRT, reference"]
@@ -13,40 +14,40 @@ Sample programs are included in the individual reference topics for most routine
 
 ## In This Section
 
-[C Run-Time Libraries](../c-runtime-library/crt-library-features.md)<br/>
+[C Run-Time Libraries](crt-library-features.md)\
 Discusses the .lib files that comprise the C run-time libraries.
 
-[Universal C runtime routines by category](../c-runtime-library/run-time-routines-by-category.md)<br/>
+[Universal C runtime routines by category](run-time-routines-by-category.md)\
 Provides links to the run-time library by category.
 
-[Global Variables and Standard Types](../c-runtime-library/global-variables-and-standard-types.md)<br/>
+[Global Variables and Standard Types](global-variables-and-standard-types.md)\
 Provides links to the global variables and standard types provided by the run-time library.
 
-[Global Constants](../c-runtime-library/global-constants.md)<br/>
+[Global Constants](global-constants.md)\
 Provides links to the global constants defined by the run-time library.
 
-[Global State](../c-runtime-library/global-state.md)<br/>
+[Global State](global-state.md)\
 Describes the scope of global state in the C run-time library.
 
-[Alphabetical Function Reference](../c-runtime-library/reference/crt-alphabetical-function-reference.md)<br/>
+[Alphabetical Function Reference](reference/crt-alphabetical-function-reference.md)\
 Provides a table of contents entry point into an alphabetical listing of all C run-time library functions.
 
-[Generic-Text Mappings](../c-runtime-library/generic-text-mappings.md)<br/>
+[Generic-Text Mappings](generic-text-mappings.md)\
 Provides links to the generic-text mappings defined in Tchar.h.
 
-[Language and Country/Region Strings](../c-runtime-library/locale-names-languages-and-country-region-strings.md)<br/>
+[Language and Country/Region Strings](locale-names-languages-and-country-region-strings.md)\
 Describes how to use the `setlocale` function to set the language and Country/Region strings.
 
 ## Related Sections
 
-[Debug Routines](../c-runtime-library/debug-routines.md)<br/>
+[Debug Routines](debug-routines.md)\
 Provides links to the debug versions of the run-time library routines.
 
-[Run-Time Error Checking](../c-runtime-library/run-time-error-checking.md)<br/>
+[Run-Time Error Checking](run-time-error-checking.md)\
 Provides links to functions that support run-time error checks.
 
-[DLLs and Visual C++ run-time library behavior](../build/run-time-library-behavior.md)<br/>
+[DLLs and Visual C++ run-time library behavior](../build/run-time-library-behavior.md)\
 Discusses the entry point and startup code used for a DLL.
 
-[Debugging](/visualstudio/debugger/debugging-in-visual-studio)<br/>
+[Debugging](/visualstudio/debugger/debugging-in-visual-studio)\
 Provides links to using the Visual Studio debugger to correct logic errors in your application or stored procedures.

docs/c-runtime-library/code-pages.md

@@ -1,5 +1,7 @@
 ---
 title: "Code Pages"
+description: "A description of code page support in the Microsoft C runtime."
+ms.topic: "conceptual"
 ms.date: "11/04/2016"
 helpviewer_keywords: ["character sets [C++], code pages", "ANSI [C++], code pages", "system-default code page", "multibyte code pages [C++]", "localization [C++], code pages", "code pages [C++], types of", "locale code pages [C++]"]
 ms.assetid: 4a26fc42-185a-4add-98bf-a7b314ae6186
@@ -8,25 +10,25 @@ ms.assetid: 4a26fc42-185a-4add-98bf-a7b314ae6186
 
 A *code page* is a character set, which can include numbers, punctuation marks, and other glyphs. Different languages and locales may use different code pages. For example, ANSI code page 1252 is used for English and most European languages; OEM code page 932 is used for Japanese Kanji.
 
-A code page can be represented in a table as a mapping of characters to single-byte values or multibyte values. Many code pages share the ASCII character set for characters in the range 0x00 - 0x7F.
+A code page can be represented in a table as a mapping of characters to single-byte or multibyte values. Many code pages share the ASCII character set for characters in the range 0x00 - 0x7F.
 
-The Microsoft run-time library uses the following types of code pages:
+The Microsoft runtime library uses the following types of code pages:
 
-- System-default ANSI code page. By default, at startup the run-time system automatically sets the multibyte code page to the system-default ANSI code page, which is obtained from the operating system. The call:
+- System-default ANSI code page. By default, at startup the runtime system automatically sets the multibyte code page to the system-default ANSI code page, which is obtained from the operating system. The call:
 
     ```C
     setlocale ( LC_ALL, "" );
     ```
 
    also sets the locale to the system-default ANSI code page.
 
-- Locale code page. The behavior of a number of run-time routines is dependent on the current locale setting, which includes the locale code page. (For more information, see [Locale-Dependent Routines](../c-runtime-library/locale.md).) By default, all locale-dependent routines in the Microsoft run-time library use the code page that corresponds to the "C" locale. At run-time you can change or query the locale code page in use with a call to [setlocale](../c-runtime-library/reference/setlocale-wsetlocale.md).
+- Locale code page. The behavior of a number of run-time routines is dependent on the current locale setting, which includes the locale code page. (For more information, see [Locale-Dependent Routines](../c-runtime-library/locale.md).) By default, all locale-dependent routines in the Microsoft run-time library use the code page that corresponds to the "C" locale. At run time, you can change or query the locale code page in use with a call to [setlocale](../c-runtime-library/reference/setlocale-wsetlocale.md).
 
 - Multibyte code page. The behavior of most of the multibyte-character routines in the run-time library depends on the current multibyte code page setting. By default, these routines use the system-default ANSI code page. At run-time you can query and change the multibyte code page with [_getmbcp](../c-runtime-library/reference/getmbcp.md) and [_setmbcp](../c-runtime-library/reference/setmbcp.md), respectively.
 
-- The "C" locale is defined by ANSI to correspond to the locale in which C programs have traditionally executed. The code page for the "C" locale ("C" code page) corresponds to the ASCII character set. For example, in the "C" locale, **islower** returns true for the values 0x61 - 0x7A only. In another locale, **islower** may return true for these as well as other values, as defined by that locale.
+- The "C" locale is defined by ANSI to correspond to the locale in which C programs have traditionally executed. The code page for the "C" locale ("C" code page) corresponds to the ASCII character set. For example, in the "C" locale, **islower** returns true for the values 0x61 - 0x7A only. In another locale, **islower** may return `true` for these and other values, as defined by that locale.
 
 ## See also
 
-[Internationalization](../c-runtime-library/internationalization.md)<br/>
-[Universal C runtime routines by category](../c-runtime-library/run-time-routines-by-category.md)<br/>
+[Internationalization](../c-runtime-library/internationalization.md)\
+[Universal C runtime routines by category](../c-runtime-library/run-time-routines-by-category.md)

docs/c-runtime-library/compatibility.md

@@ -2,6 +2,7 @@
 title: "Compatibility"
 description: "Describes the compatibility of the Microsoft Universal C runtime library (UCRT) with the Standard C library, POSIX, the Safe CRT, and Store apps."
 ms.date: "9/11/2020"
+ms.topic: "conceptual"
 helpviewer_keywords: ["CRT, compatibility", "compatibility, C runtime libraries", "compatibility"]
 ms.assetid: 346709cb-edda-4909-9a19-3d253eddb6b7
 ---

docs/c-runtime-library/controlling-streams.md

@@ -1,6 +1,8 @@
 ---
 title: "Controlling Streams"
+description: "An overview of working with streams in the Microsoft C runtime library."
 ms.date: "11/04/2016"
+ms.topic: "conceptual"
 f1_keywords: ["Controlling Streams"]
 helpviewer_keywords: ["streams, controlling", "controlling streams", "streams"]
 ms.assetid: 267e9013-9afc-45f6-91e3-ca093230d9d9

docs/c-runtime-library/crt-initialization.md

@@ -1,12 +1,14 @@
 ---
 title: "CRT Initialization"
+description: "Describes how the CRT initializes global state in native code."
+ms.topic: "conceptual"
 ms.date: "11/04/2016"
 helpviewer_keywords: ["CRT initialization [C++]"]
 ms.assetid: e7979813-1856-4848-9639-f29c86b74ad7
 ---
 # CRT Initialization
 
-This topic describes how the CRT initializes global states in native code.
+This topic describes how the CRT initializes global state in native code.
 
 By default, the linker includes the CRT library, which provides its own startup code. This startup code initializes the CRT library, calls global initializers, and then calls the user-provided `main` function for console applications.
 
@@ -30,11 +32,11 @@ int main()
 
 According to the C/C++ standard, `func()` must be called before `main()` is executed. But who calls it?
 
-One way to determine this is to set a breakpoint in `func()`, debug the application, and examine the stack. This is possible because the CRT source code is included with Visual Studio.
+One way to determine the caller is to set a breakpoint in `func()`, debug the application, and examine the stack. This is possible because the CRT source code is included with Visual Studio.
 
-When you browse the functions on the stack, you will find that the CRT is looping through a list of function pointers and calling each one as it encounters them. These functions are either similar to `func()` or constructors for class instances.
+When you browse the functions on the stack, you'll see that the CRT is calling a list of function pointers. These functions are similar to `func()`, or constructors for class instances.
 
-The CRT obtains the list of function pointers from the Microsoft C++ compiler. When the compiler sees a global initializer, it generates a dynamic initializer in the `.CRT$XCU` section (where `CRT` is the section name and `XCU` is the group name). To obtain a list of those dynamic initializers run the command **dumpbin /all main.obj**, and then search the `.CRT$XCU` section (when main.cpp is compiled as a C++ file, not a C file). It will be similar to the following:
+The CRT gets the list of function pointers from the Microsoft C++ compiler. When the compiler sees a global initializer, it generates a dynamic initializer in the `.CRT$XCU` section where `CRT` is the section name and `XCU` is the group name. To get a list of dynamic initializers, run the command **dumpbin /all main.obj**, and then search the `.CRT$XCU` section. This applies when main.cpp is compiled as a C++ file, not a C file. It will be similar to the following example:
 
 ```
 SECTION HEADER #6
@@ -56,10 +58,10 @@ RAW DATA #6
   00000000: 00 00 00 00                                      ....
 
 RELOCATIONS #6
-                                                Symbol    Symbol
+                                               Symbol    Symbol
 Offset    Type              Applied To         Index     Name
---------  ----------------  -----------------  --------  ------
-00000000  DIR32                      00000000         C  ??__Egi@@YAXXZ (void __cdecl `dynamic initializer for 'gi''(void))
+--------  ----------------  -----------------  --------  -------
+00000000  DIR32             00000000           C         ??__Egi@@YAXXZ (void __cdecl `dynamic initializer for 'gi''(void))
 ```
 
 The CRT defines two pointers:
@@ -68,11 +70,11 @@ The CRT defines two pointers:
 
 - `__xc_z` in `.CRT$XCZ`
 
-Both groups do not have any other symbols defined except `__xc_a` and `__xc_z`.
+Neither group has any other symbols defined except `__xc_a` and `__xc_z`.
 
 Now, when the linker reads various `.CRT` groups, it combines them in one section and orders them alphabetically. This means that the user-defined global initializers (which the Microsoft C++ compiler puts in `.CRT$XCU`) will always come after `.CRT$XCA` and before `.CRT$XCZ`.
 
-The section will resemble the following:
+The section will resemble the following example:
 
 ```
 .CRT$XCA
@@ -84,7 +86,7 @@ The section will resemble the following:
             __xc_z
 ```
 
-So, the CRT library uses both `__xc_a` and `__xc_z` to determine the start and end of the global initializers list because of the way in which they are laid out in memory after the image is loaded.
+So, the CRT library uses both `__xc_a` and `__xc_z` to determine the start and end of the global initializers list because of the way in which they're laid out in memory after the image is loaded.
 
 ## See also
 

docs/c-runtime-library/crt-library-features.md

@@ -1,7 +1,8 @@
 ---
 title: "CRT Library Features"
-description: "The files that contain the Microsoft C run-time libraries, and their associated compiler options and preprocessor directives."
+description: "List of files that contain the Microsoft C run-time libraries, and their associated compiler options and preprocessor directives."
 ms.date: 09/03/2020
+ms.topic: "conceptual"
 helpviewer_keywords: ["MSVCR71.dll", "libraries [C++], multithreaded", "library files, run-time", "LIBCMT.lib", "LIBCP.lib", "LIBCPMT.lib", "run-time libraries, C", "CRT, release versions", "MSVCP71.dll", "LIBC.lib", "libraries [C++]", "libraries [C++], run-time", "linking [C++], libraries"]
 ms.assetid: a889fd39-807d-48f2-807f-81492612463f
 ---

docs/c-runtime-library/direction-flag.md

@@ -1,6 +1,8 @@
 ---
 title: "Direction Flag"
+description: "Describes the effect of the CPU direction flag on Microsoft C runtime functions."
 ms.date: "11/04/2016"
+ms.topic: "conceptual"
 helpviewer_keywords: ["direction flag"]
 ms.assetid: 0836b4af-dbbb-4ab8-a4b2-156f2e2099e2
 ---

docs/c-runtime-library/files-and-streams.md

@@ -1,6 +1,8 @@
 ---
 title: "Files and Streams"
+description: "An overview of files and streams in the Microsoft C runtime library."
 ms.date: "11/04/2016"
+ms.topic: "conceptual"
 helpviewer_keywords: ["files [C++]", "streams"]
 ms.assetid: f61e712b-eac9-4c28-bb18-97c3786ef387
 ---

docs/c-runtime-library/global-state.md

@@ -1,6 +1,7 @@
 ---
 title: "Global state in the CRT"
-description: "Describes how shared global state is handled in the Universal C Runtime." 
+description: "Describes how shared global state is handled in the Microsoft Universal C Runtime." 
+ms.topic: "conceptual"
 ms.date: "04/02/2020"
 helpviewer_keywords: ["CRT global state"]
 ---

docs/c-runtime-library/internationalization.md

@@ -1,15 +1,26 @@
 ---
 title: "Internationalization"
-ms.date: "11/04/2016"
+ms.date: "09/29/2020"
+description: "A description of Microsoft runtime library support for writing apps for international markets."
+ms.topic: "conceptual"
 helpviewer_keywords: ["localization, routines for", "locale-dependent routines", "internationalization routines", "international applications, run-time routines for"]
 ms.assetid: ee536a04-3558-4729-8e10-6dabcde055fd
 ---
+
 # Internationalization
 
-The Microsoft run-time library provides many routines that are useful for creating different versions of a program for international markets. This includes [locale-related routines](../c-runtime-library/locale.md), wide-character routines, multibyte-character routines, and generic-text routines. For convenience, most locale-related routines are also categorized in this reference according to the operations they perform. In this section and in the alphabetic reference, multibyte-character routines and wide-character routines are described with single-byte-character counterparts, where they exist.
+The Microsoft runtime library provides many routines that you can use to customize your app for international markets such as:
+- [locale-related routines](../c-runtime-library/locale.md)
+- wide-character routines
+- multibyte-character routines
+- generic-text routines
+
+For convenience, most locale-related routines are also categorized by what they do.
+
+Multibyte routines and wide-character routines are described alongside their single-byte-character counterparts, when they exist.
 
-Also included are the ISO646 operator alternatives.
+ISO646 operator alternatives are also included.
 
 ## See also
 
-[Universal C runtime routines by category](../c-runtime-library/run-time-routines-by-category.md)<br/>
+[Universal C runtime routines by category](../c-runtime-library/run-time-routines-by-category.md)

docs/c-runtime-library/locale-names-languages-and-country-region-strings.md

@@ -1,5 +1,7 @@
 ---
 title: "Locale Names, Languages, and Country-Region Strings"
+description: "An overview of using Microsoft Universal CRT locale, language, and country and region strings."
+ms.topic: "conceptual"
 ms.date: "12/10/2018"
 helpviewer_keywords: ["country/region strings", "localization, locale", "locales", "setlocale function", "language strings"]
 ms.assetid: a0e5a0c5-5602-4da0-b65f-de3d6c8530a2

docs/c-runtime-library/multithreaded-libraries-performance.md

@@ -1,6 +1,8 @@
 ---
 title: "Multithreaded Libraries Performance"
+description: "An overview of how to get the most performance from the Microsoft C runtime multithreaded libraries."
 ms.date: "11/04/2016"
+ms.topic: "conceptual"
 helpviewer_keywords: ["threading [C++], performance", "libraries, multithreaded", "performance, multithreading", "multithreaded libraries"]
 ms.assetid: faa5d808-087c-463d-8f0d-8c478d137296
 ---