Merge pull request #3168 from MicrosoftDocs/master

9/28/2020 AM Publish

Author: Taojunshen

.openpublishing.redirection.json

@@ -8607,42 +8607,42 @@
     },
     {
       "source_path": "docs/windows/creating-a-new-toolbar-button.md",
-      "redirect_url": "/cpp/windows/creating-moving-and-editing-toolbar-buttons",
+      "redirect_url": "/cpp/windows/toolbar-editor",
       "redirect_document_id": false
     },
     {
       "source_path": "docs/windows/moving-a-toolbar-button.md",
-      "redirect_url": "/cpp/windows/creating-moving-and-editing-toolbar-buttons",
+      "redirect_url": "/cpp/windows/toolbar-editor",
       "redirect_document_id": false
     },
     {
       "source_path": "docs/windows/copying-buttons-from-a-toolbar.md",
-      "redirect_url": "/cpp/windows/creating-moving-and-editing-toolbar-buttons",
+      "redirect_url": "/cpp/windows/toolbar-editor",
       "redirect_document_id": false
     },
     {
       "source_path": "docs/windows/deleting-a-toolbar-button.md",
-      "redirect_url": "/cpp/windows/creating-moving-and-editing-toolbar-buttons",
+      "redirect_url": "/cpp/windows/toolbar-editor",
       "redirect_document_id": false
     },
     {
       "source_path": "docs/windows/inserting-a-space-between-buttons-on-a-toolbar.md",
-      "redirect_url": "/cpp/windows/creating-moving-and-editing-toolbar-buttons",
+      "redirect_url": "/cpp/windows/toolbar-editor",
       "redirect_document_id": false
     },
     {
       "source_path": "docs/windows/removing-space-between-buttons-on-a-toolbar.md",
-      "redirect_url": "/cpp/windows/creating-moving-and-editing-toolbar-buttons",
+      "redirect_url": "/cpp/windows/toolbar-editor",
       "redirect_document_id": false
     },
     {
       "source_path": "docs/windows/changing-the-properties-of-a-toolbar-button.md",
-      "redirect_url": "/cpp/windows/creating-moving-and-editing-toolbar-buttons",
+      "redirect_url": "/cpp/windows/toolbar-editor",
       "redirect_document_id": false
     },
     {
       "source_path": "docs/windows/toolbar-button-properties.md",
-      "redirect_url": "/cpp/windows/creating-moving-and-editing-toolbar-buttons",
+      "redirect_url": "/cpp/windows/toolbar-editor",
       "redirect_document_id": false
     },
     {

docs/build/media/vs2019-cmake-manage-configurations.png

@@ -16,7 +16,7 @@ Returns the size of a memory block allocated in the heap.
 ## Syntax
 
 ```C
-size_t _msize(
+size_t _aligned_msize(
    void *memblock,
    size_t alignment,
    size_t offset
@@ -44,15 +44,15 @@ The **_aligned_msize** function returns the size, in bytes, of the memory block
 
 When the application is linked with a debug version of the C run-time libraries, **_aligned_msize** resolves to [_aligned_msize_dbg](aligned-msize-dbg.md). For more information about how the heap is managed during the debugging process, see [The CRT Debug Heap](/visualstudio/debugger/crt-debug-heap-details).
 
-This function validates its parameter. If *memblock* is a null pointer or *alignment* is not a power of 2, **_msize** invokes an invalid parameter handler, as described in [Parameter Validation](../../c-runtime-library/parameter-validation.md). If the error is handled, the function sets **errno** to **EINVAL** and returns -1.
+This function validates its parameter. If *memblock* is a null pointer or *alignment* is not a power of 2, **_aligned_msize** invokes an invalid parameter handler, as described in [Parameter Validation](../../c-runtime-library/parameter-validation.md). If the error is handled, the function sets **errno** to **EINVAL** and returns -1.
 
 By default, this function's global state is scoped to the application. To change this, see [Global state in the CRT](../global-state.md).
 
 ## Requirements
 
 |Routine|Required header|
 |-------------|---------------------|
-|**_msize**|\<malloc.h>|
+|**_aligned_msize**|\<malloc.h>|
 
 For more compatibility information, see [Compatibility](../../c-runtime-library/compatibility.md).
 

docs/c-runtime-library/reference/aligned-msize.md

@@ -1,7 +1,7 @@
 ---
 title: "round, roundf, roundl"
-description: "API reference for round, roundf, and roundl; which round a floating-point value to the nearest integer."
-ms.date: "9/1/2020"
+description: "API reference for round, roundf, and roundl; which round a floating-point value to the nearest integer value."
+ms.date: "09/25/2020"
 api_name: ["round", "roundl", "roundf", "_o_round", "_o_roundf", "_o_roundl"]
 api_location: ["msvcrt.dll", "msvcr80.dll", "msvcr90.dll", "msvcr100.dll", "msvcr100_clr0400.dll", "msvcr110.dll", "msvcr110_clr0400.dll", "msvcr120.dll", "msvcr120_clr0400.dll", "ucrtbase.dll", "api-ms-win-crt-math-l1-1-0.dll", "api-ms-win-crt-private-l1-1-0.dll"]
 api_type: ["DLLExport"]
@@ -12,7 +12,7 @@ ms.assetid: 6be90877-193c-4b80-a32b-c3eca33f9c6f
 ---
 # round, roundf, roundl
 
-Rounds a floating-point value to the nearest integer.
+Rounds a floating-point value to the nearest integer value.
 
 ## Syntax
 
@@ -68,46 +68,60 @@ For additional compatibility information, see [Compatibility](../../c-runtime-li
 ## Example
 
 ```C
-// crt_round.c
-// Build with: cl /W3 /Tc crt_round.c
-// This example displays the rounded results of
-// the floating-point values 2.499999, -2.499999,
-// 2.8, -2.8, 2.5 and -2.5.
+// Build with: cl /W3 /Tc
+// This example displays the rounded
+// results of floating-point values
 
 #include <math.h>
 #include <stdio.h>
 
-int main( void )
+int main()
 {
-   double x = 2.499999;
-   float y = 2.8f;
-   long double z = 2.5;
-
-   printf("round(%f) is %.0f\n", x, round(x));
-   printf("round(%f) is %.0f\n", -x, round(-x));
-   printf("roundf(%f) is %.0f\n", y, roundf(y));
-   printf("roundf(%f) is %.0f\n", -y, roundf(-y));
-   printf("roundl(%Lf) is %.0Lf\n", z, roundl(z));
-   printf("roundl(%Lf) is %.0Lf\n", -z, roundl(-z));
+    printf("===== Round a float\n\n");
+    float floatValue = 2.4999999f; // float stores a value close to, but not exactly equal to, the initializer below. floatValue will contain 2.5 because it is the closest single precision value
+    printf("roundf(%.1000g) is %.1000g\n", floatValue, roundf(floatValue));
+    printf("roundf(%.1000g) is %.1000g\n", -floatValue, roundf(-floatValue));
+
+    // double stores a value close to, but not exactly equal to, the initializer below. The closest double value is just slightly larger.
+    double doubleValue = 2.4999999;
+    printf("\n===== Round a double\n\n");
+    printf("round(%.1000g) is %.1000g\n", doubleValue, round(doubleValue));
+    printf("round(%.1000g) is %.1000g\n", -doubleValue, round(-doubleValue));
+
+    // long double stores a value close to, but not exactly equal to, the initializer below. The closest long double value is just slightly larger.
+    long double longDoubleValue = 2.4999999L;
+    printf("\n===== Round a long double\n\n");
+    printf("roundl(%.1000g) is %.1000g\n", longDoubleValue, roundl(longDoubleValue));
+    printf("roundl(%.1000g) is %.1000g\n", -longDoubleValue, roundl(-longDoubleValue));
+
+    return 0;
 }
 ```
 
 ```Output
-round(2.499999) is 2
-round(-2.499999) is -2
-roundf(2.800000) is 3
-roundf(-2.800000) is -3
-roundl(2.500000) is 3
-roundl(-2.500000) is -3
+===== Round a float
+
+roundf(2.5) is 3
+roundf(-2.5) is -3
+
+===== Round a double
+
+round(2.499999900000000163657887242152355611324310302734375) is 2
+round(-2.499999900000000163657887242152355611324310302734375) is -2
+
+===== Round a long double
+
+roundl(2.499999900000000163657887242152355611324310302734375) is 2
+roundl(-2.499999900000000163657887242152355611324310302734375) is -2
 ```
 
 ## See also
 
-[Floating-Point Support](../../c-runtime-library/floating-point-support.md)<br/>
-[ceil, ceilf, ceill](ceil-ceilf-ceill.md)<br/>
-[floor, floorf, floorl](floor-floorf-floorl.md)<br/>
-[fmod, fmodf](fmod-fmodf.md)<br/>
-[lrint, lrintf, lrintl, llrint, llrintf, llrintl](lrint-lrintf-lrintl-llrint-llrintf-llrintl.md)<br/>
-[lround, lroundf, lroundl, llround, llroundf, llroundl](lround-lroundf-lroundl-llround-llroundf-llroundl.md)<br/>
-[nearbyint, nearbyintf, nearbyintl](nearbyint-nearbyintf-nearbyintl1.md)<br/>
-[rint, rintf, rintl](rint-rintf-rintl.md)<br/>
+[Floating-Point Support](../../c-runtime-library/floating-point-support.md)\
+[ceil, ceilf, ceill](ceil-ceilf-ceill.md)\
+[floor, floorf, floorl](floor-floorf-floorl.md)\
+[fmod, fmodf](fmod-fmodf.md)\
+[lrint, lrintf, lrintl, llrint, llrintf, llrintl](lrint-lrintf-lrintl-llrint-llrintf-llrintl.md)\
+[lround, lroundf, lroundl, llround, llroundf, llroundl](lround-lroundf-lroundl-llround-llroundf-llroundl.md)\
+[nearbyint, nearbyintf, nearbyintl](nearbyint-nearbyintf-nearbyintl1.md)\
+[rint, rintf, rintl](rint-rintf-rintl.md)\

docs/c-runtime-library/reference/round-roundf-roundl.md

@@ -1,6 +1,7 @@
 ---
 title: "strerror_s, _strerror_s, _wcserror_s, __wcserror_s"
-ms.date: "06/09/2020"
+description: "Functions with security enhancements to get a system error message or print a user-supplied error message."
+ms.date: "09/25/2020"
 api_name: ["__wcserror_s", "_strerror_s", "_wcserror_s", "strerror_s", "_o__strerror_s", "_o__wcserror_s", "_o_strerror_s"]
 api_location: ["msvcrt.dll", "msvcr80.dll", "msvcr90.dll", "msvcr100.dll", "msvcr100_clr0400.dll", "msvcr110.dll", "msvcr110_clr0400.dll", "msvcr120.dll", "msvcr120_clr0400.dll", "ucrtbase.dll", "api-ms-win-crt-runtime-l1-1-0.dll", "api-ms-win-crt-private-l1-1-0.dll"]
 api_type: ["DLLExport"]
@@ -36,6 +37,9 @@ errno_t __wcserror_s(
    size_t sizeInWords,
    const wchar_t *strErrMsg
 );
+```
+
+```cpp
 template <size_t size>
 errno_t strerror_s(
    char (&buffer)[size],
@@ -60,26 +64,26 @@ errno_t __wcserror_s(
 
 ### Parameters
 
-*buffer*<br/>
+*buffer*\
 Buffer to hold error string.
 
-*sizeInBytes*<br/>
+*sizeInBytes*\
 The number of bytes in the buffer.
 
-*sizeInWords*<br/>
+*sizeInWords*\
 The number of words in the buffer.
 
-*errnum*<br/>
+*errnum*\
 Error number.
 
-*strErrMsg*<br/>
+*strErrMsg*\
 User-supplied message.
 
 ## Return Value
 
 Zero if successful, an error code on failure.
 
-### Error Condtions
+### Error conditions
 
 |*buffer*|*sizeInBytes/sizeInWords*|*strErrMsg*|Contents of *buffer*|
 |--------------|------------------------|-----------------|--------------------------|
@@ -88,6 +92,8 @@ Zero if successful, an error code on failure.
 
 ## Remarks
 
+The **strerror_s** function is thread-safe.
+
 The **strerror_s** function maps *errnum* to an error-message string, returning the string in *buffer*. **_strerror_s** doesn't take the error number; it uses the current value of **errno** to determine the appropriate message. Neither **strerror_s** nor **_strerror_s** actually prints the message: For that, you need to call an output function such as [fprintf](fprintf-fprintf-l-fwprintf-fwprintf-l.md):
 
 ```C
@@ -98,7 +104,7 @@ if (( _access( "datafile",2 )) == -1 )
 }
 ```
 
-If *strErrMsg* is **NULL**, **_strerror_s** returns a string in *buffer* containing the system error message for the last library call that produced an error. The error-message string is terminated by the newline character ('\n'). If *strErrMsg* is not equal to **NULL**, then **_strerror_s** returns a string in *buffer* containing (in order) your string message, a colon, a space, the system error message for the last library call producing an error, and a newline character. Your string message can be, at most, 94 characters long.
+If *strErrMsg* is **NULL**, **_strerror_s** returns a string in *buffer* that contains the system error message for the last library call that produced an error. The error-message string is terminated by the newline character ('\n'). If *strErrMsg* isn't equal to **NULL**, then **_strerror_s** returns a string in *buffer* that contains (in order) your string message, a colon, a space, the system error message for the last library call that produced an error, and a newline character. Your string message can be, at most, 94 characters long.
 
 These functions truncate the error message if its length exceeds the size of the buffer - 1. The resulting string in *buffer* will always be null-terminated.
 
@@ -108,7 +114,7 @@ The actual error number for **_strerror_s** is stored in the variable [errno](..
 
 These functions validate their parameters. If buffer is **NULL** or if the size parameter is 0, the invalid parameter handler is invoked, as described in [Parameter Validation](../../c-runtime-library/parameter-validation.md) . If execution is allowed to continue, the functions return **EINVAL** and set **errno** to **EINVAL**.
 
-**_strerror_s**, **_wcserror_s**, and **__wcserror_s** are not part of the ANSI definition but are instead Microsoft extensions to it. Do not use them where portability is desired; for ANSI compatibility, use **strerror_s** instead.
+**_strerror_s**, **_wcserror_s**, and **__wcserror_s** aren't part of the ANSI definition but are instead Microsoft extensions to it. Don't use them where portability is desired; for ANSI compatibility, use **strerror_s** instead.
 
 In C++, using these functions is simplified by template overloads; the overloads can infer buffer length automatically, eliminating the need to specify a size argument. For more information, see [Secure Template Overloads](../../c-runtime-library/secure-template-overloads.md).
 
@@ -137,7 +143,7 @@ See the example for [perror](perror-wperror.md).
 
 ## See also
 
-[String Manipulation](../../c-runtime-library/string-manipulation-crt.md)<br/>
-[clearerr](clearerr.md)<br/>
-[ferror](ferror.md)<br/>
-[perror, _wperror](perror-wperror.md)<br/>
+[String Manipulation](../../c-runtime-library/string-manipulation-crt.md)\
+[clearerr](clearerr.md)\
+[ferror](ferror.md)\
+[perror, _wperror](perror-wperror.md)

docs/c-runtime-library/reference/strerror-s-strerror-s-wcserror-s-wcserror-s.md

@@ -11,21 +11,21 @@ In classic Windows programming, libraries are often implemented as COM objects (
 
 When you instantiate a Component Object Model (COM) object, store the interface pointer in a COM smart pointer, which performs the reference counting by using calls to `AddRef` and `Release` in the destructor. If you are using the Active Template Library (ATL) or the Microsoft Foundation Class Library (MFC), then use the `CComPtr` smart pointer. If you are not using ATL or MFC, then use `_com_ptr_t`. Because there is no COM equivalent to `std::unique_ptr`, use these smart pointers for both single-owner and multiple-owner scenarios. Both `CComPtr` and `ComQIPtr` support move operations that have rvalue references.
 
-## Example
+## Example: CComPtr
 
 The following example shows how to use `CComPtr` to instantiate a COM object and obtain pointers to its interfaces. Notice that the `CComPtr::CoCreateInstance` member function is used to create the COM object, instead of the Win32 function that has the same name.
 
 [!code-cpp[COM_smart_pointers#01](../cpp/codesnippet/CPP/how-to-create-and-use-ccomptr-and-ccomqiptr-instances_1.cpp)]
 
 `CComPtr` and its relatives are part of the ATL and are defined in \<atlcomcli.h>. `_com_ptr_t` is declared in \<comip.h>. The compiler creates specializations of `_com_ptr_t` when it generates wrapper classes for type libraries.
 
-## Example
+## Example: CComQIPt
 
 ATL also provides `CComQIPtr`, which has a simpler syntax for querying a COM object to retrieve an additional interface. However, we recommend `CComPtr` because it does everything that `CComQIPtr` can do and is semantically more consistent with raw COM interface pointers. If you use a `CComPtr` to query for an interface, the new interface pointer is placed in an out parameter. If the call fails, an HRESULT is returned, which is the typical COM pattern. With `CComQIPtr`, the return value is the pointer itself, and if the call fails, the internal HRESULT return value cannot be accessed. The following two lines show how the error handling mechanisms in `CComPtr` and `CComQIPtr` differ.
 
 [!code-cpp[COM_smart_pointers#02](../cpp/codesnippet/CPP/how-to-create-and-use-ccomptr-and-ccomqiptr-instances_2.cpp)]
 
-## Example
+## Example: IDispatch
 
 `CComPtr` provides a specialization for IDispatch that enables it to store pointers to COM automation components and invoke the methods on the interface by using late binding. `CComDispatchDriver` is a typedef for `CComQIPtr<IDispatch, &IIDIDispatch>`, which is implicitly convertible to `CComPtr<IDispatch>`. Therefore, when any of these three names appears in code, it is equivalent to `CComPtr<IDispatch>`. The following example shows how to obtain a pointer to the Microsoft Word object model by using a `CComPtr<IDispatch>`.
 

docs/cpp/how-to-create-and-use-ccomptr-and-ccomqiptr-instances.md

@@ -12,7 +12,7 @@ When using <xref:System.Diagnostics.Debug> in a Visual C++ application, the beha
 
 The behavior for <xref:System.Diagnostics.Trace> is identical to the behavior for the Debug class, but is dependent on the symbol TRACE being defined. This means that you must `#ifdef` any Trace-related code to prevent debug behavior in a release build.
 
-## Example
+## Example: Always executes output statements
 
 ### Description
 
@@ -49,7 +49,7 @@ Hello World.
 test
 ```
 
-## Example
+## Example: Use #ifdef and #endif directives
 
 ### Description
 

docs/dotnet/debug-class-cpp-cli.md

@@ -18,7 +18,7 @@ Similarly, if you export ([dllexport, dllimport](../cpp/dllexport-dllimport.md))
 
 The compiler has been updated to reduce unnecessary double thunking. For example, any function with a managed type in the signature (including return type) will implicitly be marked as `__clrcall`.
 
-## Example
+## Example: Double thunking
 
 ### Description
 
@@ -76,7 +76,7 @@ after calling struct S
 __thiscall T::~T(void)
 ```
 
-## Example
+## Example: Effect of double thunking
 
 ### Description