fix merge conflicts local

Author: Michael Blome

.openpublishing.publish.config.json

@@ -1,35 +1,36 @@
-{
-  "build_entry_point": "docs",
-  "need_generate_pdf": false,
-  "need_generate_intellisense": false,
-  "docsets_to_publish": [
-    {
-      "docset_name": "vcppdocs",
-      "build_source_folder": "docs",
-      "build_output_subfolder": "vcppdocs",
-      "locale": "en-us",
-      "version": 0,
-      "open_to_public_contributors": true,
-      "type_mapping": {
-        "Conceptual": "Content",
-        "ManagedReference": "Content",
-        "RestApi": "Content"
-      },
-      "template_folder": "_themes"
-    }
-  ],
-  "notification_subscribers": [],
-  "branches_to_filter": [],
-  "skip_source_output_uploading": false,
-  "git_repository_url_open_to_public_contributors": "https://github.com/Microsoft/cpp-docs",
-  "git_repository_branch_open_to_public_contributors": "master",  
-  "dependent_repositories": [
-    {
-      "path_to_root": "_themes",
-      "url": "https://github.com/Microsoft/templates.docs.msft",
-      "branch": "master",
-      "branch_mapping": {}
-    }
-  ],
-  "need_generate_pdf_url_template": false
-}
+{
+  "build_entry_point": "docs",
+  "need_generate_pdf": false,
+  "need_generate_intellisense": false,
+  "docsets_to_publish": [
+    {
+      "docset_name": "vcppdocs",
+      "build_source_folder": "docs",
+      "build_output_subfolder": "vcppdocs",
+      "locale": "en-us",
+      "version": 0,
+      "open_to_public_contributors": true,
+      "type_mapping": {
+        "Conceptual": "Content",
+        "ManagedReference": "Content",
+        "RestApi": "Content"
+      },
+      "template_folder": "_themes"
+    }
+  ],
+  "notification_subscribers": [],
+  "branches_to_filter": [],
+  "skip_source_output_uploading": false,
+  "git_repository_url_open_to_public_contributors": "https://github.com/Microsoft/cpp-docs",
+  "git_repository_branch_open_to_public_contributors": "master",
+  "dependent_repositories": [
+    {
+      "path_to_root": "_themes",
+      "url": "https://github.com/Microsoft/templates.docs.msft",
+      "branch": "master",
+      "branch_mapping": {}
+    }
+  ],
+  "need_generate_pdf_url_template": false,
+  "enable_incremental_build": true
+}

docs/TOC.md

@@ -1,6 +1,6 @@
-# [Visual C++ in Visual Studio 2017 RC](top/visual-cpp-in-visual-studio.md)
-# [What's New for Visual C++ in Visual Studio 2017 RC](top/what-s-new-for-visual-cpp-in-visual-studio.md)
-# [Supported Platforms (Visual C++)](top/supported-platforms-visual-cpp.md)
+# [Visual C++ in Visual Studio 2017 RC](visual-cpp-in-visual-studio.md)
+# [What's New for Visual C++ in Visual Studio 2017 RC](what-s-new-for-visual-cpp-in-visual-studio.md)
+# [Supported Platforms (Visual C++)](supported-platforms-visual-cpp.md)
 # [C Language](c-language/c-language-reference.md)
 # [C++ Language](cpp/cpp-language-reference.md)
 # [C/C++ Preprocessor](preprocessor/c-cpp-preprocessor-reference.md)
@@ -9,17 +9,17 @@
 # [Windows Development](windows/overview-of-windows-programming-in-cpp.md)
 # [Linux Development](linux/download-install-and-setup-the-linux-development-workload.md)
 # [.NET Development with C++/CLI](dotnet/dotnet-programming-with-cpp-cli-visual-cpp.md)
-# [Cloud and Web Programming in Visual C++](top/cloud-and-web-programming-in-visual-cpp.md)
-## [C++ REST SDK (Codename "Casablanca")](top/cpp-rest-sdk-codename-casablanca.md)
+# [Cloud and Web Programming in Visual C++](cloud/cloud-and-web-programming-in-visual-cpp.md)
+## [C++ REST SDK (Codename "Casablanca")](cloud/cpp-rest-sdk-codename-casablanca.md)
 # [Parallel Programming](parallel/parallel-programming-in-visual-cpp.md)
 # [Data Access](data/data-access-programming-mfc-atl.md)
 # [Text and Strings](text/text-and-strings-in-visual-cpp.md)
 # [Using the Visual Studio IDE for C++](ide/ide-and-tools-for-visual-cpp-development.md)
 # [Compilers and Build Tools](build/building-c-cpp-programs.md)
 # [Porting and Upgrading Visual C++ Code](porting/visual-cpp-porting-and-upgrading-guide.md)
-# [Security Best Practices for C++](top/security-best-practices-for-cpp.md)
-## [Running as a Member of the Users Group](top/running-as-a-member-of-the-users-group.md)
-## [How User Account Control (UAC) Affects Your Application](top/how-user-account-control-uac-affects-your-application.md)
-# [Visual C++ Samples](top/visual-cpp-samples.md)
-# [Visual C++ Help and Community](top/visual-cpp-help-and-community.md)
-# [How to Report a Problem with the Visual C++ Toolset](top/how-to-report-a-problem-with-the-visual-cpp-toolset.md)
+# [Security Best Practices for C++](security/security-best-practices-for-cpp.md)
+## [Running as a Member of the Users Group](security/running-as-a-member-of-the-users-group.md)
+## [How User Account Control (UAC) Affects Your Application](security/how-user-account-control-uac-affects-your-application.md)
+# [Visual C++ Samples](visual-cpp-samples.md)
+# [Visual C++ Help and Community](visual-cpp-help-and-community.md)
+# [How to Report a Problem with the Visual C++ Toolset](how-to-report-a-problem-with-the-visual-cpp-toolset.md)

docs/_breadcrumb/toc.yml

@@ -117,4 +117,10 @@
         topicHref: /cpp/porting/porting-and-upgrading-guide
       - name: Text and Strings
         tocHref: /cpp/text/
-        topicHref: /cpp/text/text-and-strings
+        topicHref: /cpp/text/text-and-strings
+      - name: Security
+        tocHref: /cpp/security
+        topicHref: /cpp/security/security-best-practices-for-cpp
+      - name: Cloud and Web
+        tocHref: /cpp/cloud
+        topicHref: /cpp/cloud/cloud-and-web-programming-in-visual-cpp

docs/assembler/masm/microsoft-macro-assembler-reference.md

@@ -61,7 +61,7 @@ The Microsoft Macro Assembler (MASM) provides several advantages over inline ass
  Information about how to create output files for [!INCLUDE[vcprx64](../../assembler/inline/includes/vcprx64_md.md)].  
 
 ## Related Sections  
- [Visual C++](../../visual-cpp-in-visual-studio.md)  
+ [Visual C++](../../top/visual-cpp-in-visual-studio.md)  
  Provides links to different areas of the Visual Studio and Visual C++ documentation.  
 
  [Visual C++ Reference](http://msdn.microsoft.com/en-us/1ba03b5c-8229-4f63-b08c-6c12141d6ab1)  

docs/atl-mfc-shared/allocating-and-releasing-memory-for-a-bstr.md

@@ -62,7 +62,7 @@ When you create `BSTR`s and pass them between COM objects, you must take care in
 
 ## See Also  
  [Strings (ATL/MFC)](../atl-mfc-shared/strings-atl-mfc.md)   
- [CStringT::AllocSysString](../atl-mfc-shared/reference/cstringt-class.md#cstringt__allocsysstring)   
+ [CStringT::AllocSysString](../atl-mfc-shared/reference/cstringt-class.md#allocsysstring)   
  [SysAllocString](http://msdn.microsoft.com/en-us/9e0437a2-9b4a-4576-88b0-5cb9d08ca29b)   
  [SysFreeString](http://msdn.microsoft.com/en-us/8f230ee3-5f6e-4cb9-a910-9c90b754dcd3)
 

docs/atl-mfc-shared/atl-mfc-shared-classes.md

@@ -67,7 +67,7 @@ Beginning with Visual C++ .NET 2002, several existing MFC utility classes were r
  Provides links to sample code showing the capabilities of Visual C++ and the libraries and technologies it supports.  
 
  [Visual C++ Libraries](http://msdn.microsoft.com/en-us/fec23c40-10c0-4857-9cdc-33a3b99b30ae)  
- Provides links to the various libraries provided with Visual C++, including ATL, MFC, OLE DB Templates, the C run-time library, and the Standard C++ Library.  
+ Provides links to the various libraries provided with Visual C++, including ATL, MFC, OLE DB Templates, the C run-time library, and the C++ Standard Library.  
 
  [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/atl-mfc-shared/cfixedstringt-example-of-a-custom-string-manager.md

@@ -70,7 +70,7 @@ The ATL library implements one example of a custom string manager used by class
 ## Implementation of CFixedStringMgr::GetNilString  
  The implementation of **CFixedStringMgr::GetNilString** returns the fixed buffer. Because of the one-on-one correspondence of **CFixedStringMgr** and `CStringT`, a given instance of `CStringT` never uses more than one buffer at a time. Therefore, a nil string and a real string buffer are never needed at the same time.  
 
- Whenever the fixed buffer is not in use, **CFixedStringMgr** ensures that it is initialized with a zero length. This allows it to be used as the nil string. As an added bonus, the `nAllocLength` member of the fixed buffer is always set to the full size of the fixed buffer. This means that `CStringT` can grow the string without calling [IAtlStringMgr::Reallocate](../atl-mfc-shared/reference/iatlstringmgr-class.md#iatlstringmgr__reallocate), even for the nil string.  
+ Whenever the fixed buffer is not in use, **CFixedStringMgr** ensures that it is initialized with a zero length. This allows it to be used as the nil string. As an added bonus, the `nAllocLength` member of the fixed buffer is always set to the full size of the fixed buffer. This means that `CStringT` can grow the string without calling [IAtlStringMgr::Reallocate](../atl-mfc-shared/reference/iatlstringmgr-class.md#reallocate), even for the nil string.  
 
 ## Requirements  
  **Header:** cstringt.h  

docs/atl-mfc-shared/date-and-time-automation-support.md

@@ -55,7 +55,7 @@ This article describes how to take advantage of the class library services relat
 
  The `COleDateTime` and `COleDateTimeSpan` classes are designed to be used with the `COleVariant` class used in Automation. `COleDateTime` and `COleDateTimeSpan` are also useful in MFC database programming, but they can be used whenever you want to manipulate date and time values. Although the `COleDateTime` class has a greater range of values and finer granularity than the `CTime` class, it requires more storage per object than `CTime`. There are also some special considerations when working with the underlying **DATE** type. See [The DATE Type](../atl-mfc-shared/date-type.md) for more details on the implementation of **DATE**.  
 
- `COleDateTime` objects can be used to represent dates between January 1, 100, and December 31, 9999. `COleDateTime` objects are floating point values, with an approximate resolution of 1 millisecond. `COleDateTime` is based on the **DATE** data type, defined in the MFC documentation under [COleDateTime::operator DATE](../atl-mfc-shared/reference/coledatetime-class.md#coledatetime__operator_date). The actual implementation of **DATE** extends beyond these bounds. The `COleDateTime` implementation imposes these bounds to facilitate working with the class.  
+ `COleDateTime` objects can be used to represent dates between January 1, 100, and December 31, 9999. `COleDateTime` objects are floating point values, with an approximate resolution of 1 millisecond. `COleDateTime` is based on the **DATE** data type, defined in the MFC documentation under [COleDateTime::operator DATE](../atl-mfc-shared/reference/coledatetime-class.md#operator_date). The actual implementation of **DATE** extends beyond these bounds. The `COleDateTime` implementation imposes these bounds to facilitate working with the class.  
 
  `COleDateTime` does not support Julian dates. The Gregorian calendar is assumed to extend back in time to January 1, 100.  
 

docs/atl-mfc-shared/date-and-time-systemtime-support.md

@@ -56,7 +56,7 @@ The [CTime](../atl-mfc-shared/reference/ctime-class.md) class has constructors t
 
  If your code contains a `CTime` object initialized with the system time, you should use the `SYSTEMTIME` constructor in Win32.  
 
- You most likely will not use `CTime` `FILETIME` initialization directly. If you use a `CFile` object to manipulate a file, [CFile::GetStatus](../mfc/reference/cfile-class.md#cfile__getstatus) retrieves the file timestamp for you via a `CTime` object initialized with a `FILETIME` structure.  
+ You most likely will not use `CTime` `FILETIME` initialization directly. If you use a `CFile` object to manipulate a file, [CFile::GetStatus](../mfc/reference/cfile-class.md#getstatus) retrieves the file timestamp for you via a `CTime` object initialized with a `FILETIME` structure.  
 
 ## What do you want to know more about  
 

docs/atl-mfc-shared/exporting-string-classes-using-cstringt.md

@@ -37,7 +37,7 @@ In the past, MFC developers have derived from `CString` to specialize their own
 
 -   It allowed the MFC `CString` class to be used in ATL projects without linking in the larger MFC static library or DLL.  
 
--   With the new `CStringT` template class, you can customize `CString` behavior using template parameters that specify character traits, similar to the templates in the Standard Template Library (STL).  
+-   With the new `CStringT` template class, you can customize `CString` behavior using template parameters that specify character traits, similar to the templates in the C++ Standard Library.  
 
 -   When you export your own string class from a DLL using `CStringT`, the compiler also automatically exports the `CString` base class. Since `CString` is itself a template class, it may be instantiated by the compiler when used, unless the compiler is aware that `CString` is imported from a DLL. If you have migrated projects from Visual C++ 6.0 to Visual C++.NET, you might have seen linker symbol errors for a multiply-defined `CString` because of the collision of the `CString` imported from a DLL and the locally instantiated version. The proper way to do this is described below. For more information on this issue, see the Knowledge Base article, "Linking Errors When you Import CString-derived Classes" (Q309801) on the MSDN Library CD-ROM or at [http://support.microsoft.com/default.aspx](http://support.microsoft.com/default.aspx).  
 

docs/atl-mfc-shared/implementation-of-a-custom-string-manager-advanced-method.md

@@ -39,13 +39,13 @@ In specialized situations, you might want to implement a custom string manager t
 
  The `CStringData` structure comprises four fields:  
 
--   [pStringMgr](../atl-mfc-shared/reference/cstringdata-class.md#cstringdata__pstringmgr) This field points to the `IAtlStringMgr` interface used to manage this string data. When `CStringT` needs to reallocate or free the string buffer it calls the Reallocate or Free methods of this interface, passing the `CStringData` structure as a parameter. When allocating a `CStringData` structure in your string manager, you must set this field to point to your custom string manager.  
+-   [pStringMgr](../atl-mfc-shared/reference/cstringdata-class.md#pstringmgr) This field points to the `IAtlStringMgr` interface used to manage this string data. When `CStringT` needs to reallocate or free the string buffer it calls the Reallocate or Free methods of this interface, passing the `CStringData` structure as a parameter. When allocating a `CStringData` structure in your string manager, you must set this field to point to your custom string manager.  
 
--   [nDataLength](../atl-mfc-shared/reference/cstringdata-class.md#cstringdata__ndatalength) This field contains the current logical length of the string stored in the buffer excluding the terminating null. `CStringT` updates this field when the length of the string changes. When allocating a `CStringData` structure, your string manager must set this field to zero. When reallocating a `CStringData` structure, your custom string manager must leave this field unchanged.  
+-   [nDataLength](../atl-mfc-shared/reference/cstringdata-class.md#ndatalength) This field contains the current logical length of the string stored in the buffer excluding the terminating null. `CStringT` updates this field when the length of the string changes. When allocating a `CStringData` structure, your string manager must set this field to zero. When reallocating a `CStringData` structure, your custom string manager must leave this field unchanged.  
 
--   [nAllocLength](../atl-mfc-shared/reference/cstringdata-class.md#cstringdata__nalloclength) This field contains the maximum number of characters (excluding the terminating null) that can be stored in this string buffer without reallocating it. Whenever `CStringT` needs to increase the logical length of the string, it first checks this field to make sure there is enough space in the buffer. If the check fails, `CStringT` calls into your custom string manager to reallocate the buffer. When allocating or reallocating a `CStringData` structure, you must set this field to at least the number of characters requested in the **nChars** parameter to [IAtlStringMgr::Allocate](../atl-mfc-shared/reference/iatlstringmgr-class.md#iatlstringmgr__allocate) or [IAtlStringMgr::Reallocate](../atl-mfc-shared/reference/iatlstringmgr-class.md#iatlstringmgr__reallocate). If there is more space in the buffer than requested, you can set this value to reflect the actual amount of space available. This allows `CStringT` to grow the string to fill the entire allocated space before it has to call back into the string manager to reallocate the buffer.  
+-   [nAllocLength](../atl-mfc-shared/reference/cstringdata-class.md#nalloclength) This field contains the maximum number of characters (excluding the terminating null) that can be stored in this string buffer without reallocating it. Whenever `CStringT` needs to increase the logical length of the string, it first checks this field to make sure there is enough space in the buffer. If the check fails, `CStringT` calls into your custom string manager to reallocate the buffer. When allocating or reallocating a `CStringData` structure, you must set this field to at least the number of characters requested in the **nChars** parameter to [IAtlStringMgr::Allocate](../atl-mfc-shared/reference/iatlstringmgr-class.md#allocate) or [IAtlStringMgr::Reallocate](../atl-mfc-shared/reference/iatlstringmgr-class.md#reallocate). If there is more space in the buffer than requested, you can set this value to reflect the actual amount of space available. This allows `CStringT` to grow the string to fill the entire allocated space before it has to call back into the string manager to reallocate the buffer.  
 
--   [nRefs](../atl-mfc-shared/reference/cstringdata-class.md#cstringdata__nrefs) This field contains the current reference count of the string buffer. If the value is one, then a single instance of `CStringT` is using the buffer. In addition, the instance is allowed to both read and modify the contents of the buffer. If the value is greater than one, multiple instances of `CStringT` can use the buffer. Because the character buffer is shared, `CStringT` instances can only read the contents of the buffer. To modify the contents, `CStringT` first makes a copy of the buffer. If the value is negative, only one instance of `CStringT` is using the buffer. In this case, the buffer is considered locked. When a `CStringT` instance is using a locked buffer no other instances of `CStringT` may share the buffer. Instead, these instances create a copy of the buffer before manipulating the contents. In addition, the `CStringT` instance using the locked buffer does not attempt to share the buffer of any other `CStringT` instance assigned to it. In this case, the `CStringT` instance copies the other string into the locked buffer.  
+-   [nRefs](../atl-mfc-shared/reference/cstringdata-class.md#nrefs) This field contains the current reference count of the string buffer. If the value is one, then a single instance of `CStringT` is using the buffer. In addition, the instance is allowed to both read and modify the contents of the buffer. If the value is greater than one, multiple instances of `CStringT` can use the buffer. Because the character buffer is shared, `CStringT` instances can only read the contents of the buffer. To modify the contents, `CStringT` first makes a copy of the buffer. If the value is negative, only one instance of `CStringT` is using the buffer. In this case, the buffer is considered locked. When a `CStringT` instance is using a locked buffer no other instances of `CStringT` may share the buffer. Instead, these instances create a copy of the buffer before manipulating the contents. In addition, the `CStringT` instance using the locked buffer does not attempt to share the buffer of any other `CStringT` instance assigned to it. In this case, the `CStringT` instance copies the other string into the locked buffer.  
 
      When allocating a `CStringData` structure, you must set this field to reflect the type of sharing that is allowed for the buffer. For most implementations, set this value to one. This allows the usual copy-on-write sharing behavior. However, if your string manager does not support sharing the string buffer, set this field to a locked state. This forces `CStringT` to only use this buffer for the instance of `CStringT` that allocated it.