Merge pull request MicrosoftDocs#2299 from MicrosoftDocs/master637298271429493867

Fix git push error for protected CLA branch

Author: Colin Robertson

docs/build/reference/heap.md

@@ -1,28 +1,42 @@
 ---
 title: "/HEAP"
-ms.date: "11/04/2016"
+description: "The MSVC linker or EDITBIN /HEAP option sets the total heap size, and optionally the size of additional heap blocks."
+ms.date: 07/07/2020
 f1_keywords: ["/heap"]
 helpviewer_keywords: ["heap allocation, setting heap size", "HEAP editbin option", "-HEAP editbin option", "/HEAP editbin option"]
 ms.assetid: 6ce759b5-75b7-44ff-a5fd-3a83a0ba9a48
 ---
-# /HEAP
+# `/HEAP`
 
 Sets the size of the heap in bytes. This option only applies to executable files.
 
-```
+## Syntax
 
-/HEAP:
-reserve[,commit]
-```
+> **`/HEAP:`**_`reserve`_\[**`,`**_`commit`_]
 
 ## Remarks
 
-The `reserve` argument specifies the total initial heap allocation in virtual memory. By default, the heap size is 1 MB. [EDITBIN Reference](editbin-reference.md) rounds up the specified value to the nearest multiple of 4 bytes.
+The *`reserve`* argument specifies the total initial heap allocation in virtual memory. The **`/HEAP`** linker or [EDITBIN](editbin-reference.md) option rounds up the specified value to the nearest multiple of 4 bytes. By default, the heap size is 1 MB.
 
-The optional `commit` argument is subject to interpretation by the operating system. On a Windows operating system, it specifies the initial amount of physical memory to allocate, and the amount of additional memory to allocate when the heap must be expanded. Committed virtual memory causes space to be reserved in the paging file. A higher `commit` value allows the system to allocate memory less often when the app needs more heap space but increases the memory requirements and possibly the app startup duration. The `commit` value must be less than or equal to the `reserve` value.
+The optional *`commit`* argument is subject to interpretation by the operating system. On a Windows operating system, it specifies the initial amount of physical memory to allocate. It also specifies how much more memory to allocate when the heap is expanded. Committed virtual memory causes space to be reserved in the paging file. A higher *`commit`* value allows the system to allocate memory less often when the app needs more heap space but increases the memory requirements and possibly the app startup duration. The *`commit`* value must be less than or equal to the *`reserve`* value. The default value is 4 KB.
 
-Specify the `reserve` and `commit` values in decimal or C-language hexadecimal or octal notation. For example, a value of 1 MB can be specified as 1048576 in decimal, or as 0x100000 in hexadecimal, or as 04000000 in octal.
+Specify the *`reserve`* and *`commit`* values in decimal, C-language hexadecimal, or octal notation. For example, a value of 1 MB can be specified as 1048576 in decimal, or as 0x100000 in hexadecimal, or as 04000000 in octal. The default values are equivalent to the option **`/HEAP:1048576,4096`**.
+
+### Example
+
+This example link command creates an executable *main.exe* that has heap reserve of 2 MB. The initial heap and later heap expansions come in blocks of 64 KB:
+
+**`link /heap:0x200000,0x10000 main.obj`**
+
+### To set this linker option in Visual Studio
+
+1. Open the project **Property Pages** dialog box. For more information, see [Set C++ compiler and build properties in Visual Studio](../working-with-project-properties.md).
+
+1. Select the **Configuration Properties** > **Linker** > **System** property page.
+
+1. Set the **Heap Reserve Size** and **Heap Commit Size** properties, then choose **OK** or **Apply** to save your changes.
 
 ## See also
 
-[EDITBIN Options](editbin-options.md)
+[EDITBIN options](editbin-options.md)\
+[MSVC linker options](linker-options.md)

docs/cpp/com-ptr-t-extractors.md

@@ -1,19 +1,20 @@
 ---
 title: "_com_ptr_t Extractors"
-ms.date: "11/04/2016"
+description: "Describes the extraction operators for the _com_ptr_t class."
+ms.date: 07/07/2020
 f1_keywords: ["_com_ptr_t::operatorInterface&", "_com_ptr_t::operatorbool", "_com_ptr_t::operator->", "_com_ptr_t::operator*"]
 helpviewer_keywords: ["operator Interface& [C++]", "* operator [C++], with specific objects", "operator& [C++]", "operator* [C++]", "-> operator [C++], with specific objects", "& operator [C++], with specific objects", "operator Interface* [C++]", "operator * [C++]", "operator->", "operator bool", "extractors, _com_ptr_t class", "extractors [C++]"]
 ms.assetid: 194b9e0e-123c-49ff-a187-0a7fcd68145a
 ---
-# _com_ptr_t Extractors
+# `_com_ptr_t` Extractors
 
-**Microsoft Specific**
+**Microsoft-specific**
 
 Extract the encapsulated COM interface pointer.
 
 ## Syntax
 
-```
+```c++
 operator Interface*( ) const throw( );
 operator Interface&( ) const;
 Interface& operator*( ) const;
@@ -24,20 +25,21 @@ operator bool( ) const throw( );
 
 ## Remarks
 
-- **operator Interface**<strong>\*</strong> Returns the encapsulated interface pointer, which may be NULL.
+- **`operator Interface*`** Returns the encapsulated interface pointer, which may be NULL.
 
-- **operator Interface&** Returns a reference to the encapsulated interface pointer, and issues an error if the pointer is NULL.
+- **`operator Interface&`** Returns a reference to the encapsulated interface pointer, and issues an error if the pointer is NULL.
 
-- **operator**<strong>\*</strong> Allows a smart pointer object to act as though it were the actual encapsulated interface when dereferenced.
+- **`operator*`** Allows a smart pointer object to act as though it were the actual encapsulated interface when dereferenced.
 
-- **operator->** Allows a smart pointer object to act as though it were the actual encapsulated interface when dereferenced.
+- **`operator->`** Allows a smart pointer object to act as though it were the actual encapsulated interface when dereferenced.
 
-- **operator&** Releases any encapsulated interface pointer, replacing it with NULL, and returns the address of the encapsulated pointer. This allows the smart pointer to be passed by address to a function that has an *out* parameter through which it returns an interface pointer.
+- **`operator&`** Releases any encapsulated interface pointer, replacing it with NULL, and returns the address of the encapsulated pointer. This operator allows you to pass the smart pointer by address to a function that has an *out* parameter through which it returns an interface pointer.
 
-- **operator bool** Allows a smart pointer object to be used in a conditional expression. This operator returns TRUE if the pointer is not NULL.
+- **`operator bool`** Allows a smart pointer object to be used in a conditional expression. This operator returns TRUE if the pointer isn't NULL.
 
-**END Microsoft Specific**
+  > [!NOTE]
+  > Because **`operator bool`** is not declared as **`explicit`**, `_com_ptr_t` is implicitly convertible to **`bool`**, which is convertible to any scalar type. This can have unexpected consequences in your code. Enable [Compiler Warning (level 4) C4800](../error-messages/compiler-warnings/compiler-warning-level-3-c4800.md) to prevent unintentional use of this conversion.
 
 ## See also
 
-[_com_ptr_t Class](../cpp/com-ptr-t-class.md)
+[_com_ptr_t class](../cpp/com-ptr-t-class.md)

docs/cpp/new-and-delete-operators.md

@@ -1,43 +1,43 @@
 ---
-title: "new and delete Operators"
-ms.date: "11/19/2019"
+title: "new and delete operators"
+description: "The C++ language new and delete operators allow control over allocation."
+ms.date: 07/07/2020
 helpviewer_keywords: ["new keyword [C++]", "delete keyword [C++]"]
-ms.assetid: fa721b9e-0374-4f04-bb87-032ea775bcc8
 ---
-# new and delete operators
+# `new` and `delete` operators
 
-C++ supports dynamic allocation and deallocation of objects using the [new](new-operator-cpp.md) and [delete](delete-operator-cpp.md) operators. These operators allocate memory for objects from a pool called the free store. The **new** operator calls the special function [operator new](new-operator-cpp.md), and the **delete** operator calls the special function [operator delete](delete-operator-cpp.md).
+C++ supports dynamic allocation and deallocation of objects using the [`new`](new-operator-cpp.md) and [`delete`](delete-operator-cpp.md) operators. These operators allocate memory for objects from a pool called the free store. The **`new`** operator calls the special function [`operator new`](new-operator-cpp.md), and the **`delete`** operator calls the special function [`operator delete`](delete-operator-cpp.md).
 
-The **new** function in the C++ Standard Library supports the behavior specified in the C++ standard, which is to throw a std::bad_alloc exception if the memory allocation fails. If you still want the non-throwing version of **new**, link your program with nothrownew.obj. However, when you link with nothrownew.obj, the default **operator new** in the C++ Standard Library no longer functions.
+The **`new`** function in the C++ Standard Library supports the behavior specified in the C++ standard, which is to throw a `std::bad_alloc` exception if the memory allocation fails. If you still want the non-throwing version of **`new`**, link your program with *`nothrownew.obj`*. However, when you link with *`nothrownew.obj`*, the default **`operator new`** in the C++ Standard Library no longer functions.
 
-For a list of the library files that comprise the C Runtime Library and the C++ Standard Library, see [CRT Library Features](../c-runtime-library/crt-library-features.md).
+For a list of the library files in the C Runtime Library and the C++ Standard Library, see [CRT Library Features](../c-runtime-library/crt-library-features.md).
 
-## <a id="new_operator"> </a> The new operator
+## <a id="new_operator"> </a> The `new` operator
 
-When a statement such as the following is encountered in a program, it translates into a call to the function **operator new**:
+The compiler translates a statement such as this one into a call to the function **`operator new`**:
 
 ```cpp
 char *pch = new char[BUFFER_SIZE];
 ```
 
-If the request is for zero bytes of storage, **operator new** returns a pointer to a distinct object (that is, repeated calls to **operator new** return different pointers). If there is insufficient memory for the allocation request, **operator new** throws a `std::bad_alloc` exception, or returns **nullptr** if you have linked in non-throwing **operator new** support.
+If the request is for zero bytes of storage, **`operator new`** returns a pointer to a distinct object. That is, repeated calls to **`operator new`** return different pointers. If there's insufficient memory for the allocation request, **`operator new`** throws a `std::bad_alloc` exception. Or, it returns **`nullptr`** if you've linked in non-throwing **`operator new`** support.
 
-You can write a routine that attempts to free memory and retry the allocation; see [_set_new_handler](../c-runtime-library/reference/set-new-handler.md) for more information. For more details on the recovery scheme, see the Handling insufficient memory section of this topic.
+You can write a routine that attempts to free memory and retry the allocation. For more information, see [`_set_new_handler`](../c-runtime-library/reference/set-new-handler.md). For details on the recovery scheme, see the [Handling insufficient memory](#handling-insufficient-memory) section.
 
-The two scopes for **operator new** functions are described in the following table.
+The two scopes for **`operator new`** functions are described in the following table.
 
-### Scope for operator new functions
+### Scope for `operator new` functions
 
-|Operator|Scope|
-|--------------|-----------|
-|**::operator new**|Global|
-|*class-name* **::operator new**|Class|
+| Operator | Scope |
+|--|--|
+| **`::operator new`** | Global |
+| *class-name* **`::operator new`** | Class |
 
-The first argument to **operator new** must be of type `size_t` (a type defined in \<stddef.h>), and the return type is always **void** <strong>\*</strong>.
+The first argument to **`operator new`** must be of type `size_t`, defined in \<stddef.h>, and the return type is always **`void*`**.
 
-The global **operator new** function is called when the **new** operator is used to allocate objects of built-in types, objects of class type that do not contain user-defined **operator new** functions, and arrays of any type. When the **new** operator is used to allocate objects of a class type where an **operator new** is defined, that class's **operator new** is called.
+The global **`operator new`** function is called when the **`new`** operator is used to allocate objects of built-in types, objects of class type that don't contain user-defined **`operator new`** functions, and arrays of any type. When the **`new`** operator is used to allocate objects of a class type where an **`operator new`** is defined, that class's **`operator new`** is called.
 
-An **operator new** function defined for a class is a static member function (which cannot, therefore, be virtual) that hides the global **operator new** function for objects of that class type. Consider the case where **new** is used to allocate and set memory to a given value:
+An **`operator new`** function defined for a class is a static member function (which can't be virtual) that hides the global **`operator new`** function for objects of that class type. Consider the case where **`new`** is used to allocate and set memory to a given value:
 
 ```cpp
 #include <malloc.h>
@@ -66,13 +66,13 @@ int main()
 }
 ```
 
-The argument supplied in parentheses to **new** is passed to `Blanks::operator new` as the `chInit` argument. However, the global **operator new** function is hidden, causing code such as the following to generate an error:
+The argument supplied in parentheses to **`new`** is passed to `Blanks::operator new` as the `chInit` argument. However, the global **`operator new`** function is hidden, causing code such as the following to generate an error:
 
 ```cpp
 Blanks *SomeBlanks = new Blanks;
 ```
 
-The compiler supports member array **new** and **delete** operators in a class declaration. For example:
+The compiler supports member array **`new`** and **`delete`** operators in a class declaration. For example:
 
 ```cpp
 class MyClass
@@ -111,28 +111,28 @@ int main() {
 }
 ```
 
-There is another way to handle failed memory allocation requests. Write a custom recovery routine to handle such a failure, then register your function by calling the [_set_new_handler](../c-runtime-library/reference/set-new-handler.md) run-time function.
+There's another way to handle failed memory allocation requests. Write a custom recovery routine to handle such a failure, then register your function by calling the [`_set_new_handler`](../c-runtime-library/reference/set-new-handler.md) run-time function.
 
-## <a id="delete_operator"> </a> The delete operator
+## <a id="delete_operator"> </a> The `delete` operator
 
-Memory that is dynamically allocated using the **new** operator can be freed using the **delete** operator. The delete operator calls the **operator delete** function, which frees memory back to the available pool. Using the **delete** operator also causes the class destructor (if there is one) to be called.
+Memory that is dynamically allocated using the **`new`** operator can be freed using the **`delete`** operator. The delete operator calls the **`operator delete`** function, which frees memory back to the available pool. Using the **`delete`** operator also causes the class destructor (if one exists) to be called.
 
-There are global and class-scoped **operator delete** functions. Only one **operator delete** function can be defined for a given class; if defined, it hides the global **operator delete** function. The global **operator delete** function is always called for arrays of any type.
+There are global and class-scoped **`operator delete`** functions. Only one **`operator delete`** function can be defined for a given class; if defined, it hides the global **`operator delete`** function. The global **`operator delete`** function is always called for arrays of any type.
 
-The global **operator delete** function. Two forms exist for the  global **operator delete**  and class-member **operator delete** functions:
+The global **`operator delete`** function. Two forms exist for the  global **`operator delete`**  and class-member **`operator delete`** functions:
 
 ```cpp
 void operator delete( void * );
 void operator delete( void *, size_t );
 ```
 
-Only one of the preceding two forms can be present for a given class. The first form takes a single argument of type `void *`, which contains a pointer to the object to deallocate. The second form—sized deallocation—takes two arguments, the first of which is a pointer to the memory block to deallocate and the second of which is the number of bytes to deallocate. The return type of both forms is **void** (**operator delete** cannot return a value).
+Only one of the preceding two forms can be present for a given class. The first form takes a single argument of type **`void *`**, which contains a pointer to the object to deallocate. The second form, sized deallocation, takes two arguments: the first is a pointer to the memory block to deallocate, and the second is the number of bytes to deallocate. The return type of both forms is **`void`** (**`operator delete`** can't return a value).
 
-The intent of the second form is to speed up searching for the correct size category of the object to be deleted, which is often not stored near the allocation itself and likely uncached. The second form is useful when an **operator delete** function from a base class is used to delete an object of a derived class.
+The intent of the second form is to speed up searching for the correct size category of the object to delete. This information often isn't stored near the allocation itself, and is likely uncached. The second form is useful when an **`operator delete`** function from a base class is used to delete an object of a derived class.
 
-The **operator delete** function is static; therefore, it cannot be virtual. The **operator delete** function obeys access control, as described in [Member-Access Control](member-access-control-cpp.md).
+The **`operator delete`** function is static, so it can't be virtual. The **`operator delete`** function obeys access control, as described in [Member-Access Control](member-access-control-cpp.md).
 
-The following example shows user-defined **operator new** and **operator delete** functions designed to log allocations and deallocations of memory:
+The following example shows user-defined **`operator new`** and **`operator delete`** functions designed to log allocations and deallocations of memory:
 
 ```cpp
 #include <iostream>
@@ -180,9 +180,9 @@ int main( int argc, char *argv[] ) {
 }
 ```
 
-The preceding code can be used to detect "memory leakage" — that is, memory that is allocated on the free store but never freed. To perform this detection, the global **new** and **delete** operators are redefined to count allocation and deallocation of memory.
+The preceding code can be used to detect "memory leakage", that is, memory that's allocated on the free store but never freed. To detect leaks, the global **`new`** and **`delete`** operators are redefined to count allocation and deallocation of memory.
 
-The compiler supports member array **new** and **delete** operators in a class declaration. For example:
+The compiler supports member array **`new`** and **`delete`** operators in a class declaration. For example:
 
 ```cpp
 // spec1_the_operator_delete_function2.cpp