Change obsolete STL references (MicrosoftDocs#117)

* Clean up obsolete references to STL

* Catch some STL stragglers

Author: Colin Robertson

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/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/TOC.md

@@ -35,7 +35,7 @@
 ## [ATL Collections and Enumerators](atl-collections-and-enumerators.md)
 ### [ATL Collection and Enumerator Classes](atl-collection-and-enumerator-classes.md)
 ### [Design Principles for Collection and Enumerator Interfaces](design-principles-for-collection-and-enumerator-interfaces.md)
-### [Implementing an STL-Based Collection](implementing-an-stl-based-collection.md)
+### [Implementing a C++ Standard Library-Based Collection](implementing-an-stl-based-collection.md)
 #### [ATL Copy Policy Classes](atl-copy-policy-classes.md)
 ## [ATL Composite Control Fundamentals](atl-composite-control-fundamentals.md)
 ### [Inserting a Composite Control](inserting-a-composite-control.md)

docs/atl/atl-collection-and-enumerator-classes.md

@@ -39,13 +39,13 @@ ATL provides the following classes to help you implement collections and enumera
 |Class|Description|  
 |-----------|-----------------|  
 |[ICollectionOnSTLImpl](../atl/reference/icollectiononstlimpl-class.md)|Collection interface implementation|  
-|[IEnumOnSTLImpl](../atl/reference/ienumonstlimpl-class.md)|Enumerator interface implementation (assumes data stored in an STL-compatible container)|  
+|[IEnumOnSTLImpl](../atl/reference/ienumonstlimpl-class.md)|Enumerator interface implementation (assumes data stored in a C++ Standard Library-compatible container)|  
 |[CComEnumImpl](../atl/reference/ccomenumimpl-class.md)|Enumerator interface implementation (assumes data stored in an array)|  
 |[CComEnumOnSTL](../atl/reference/ccomenumonstl-class.md)|Enumerator object implementation (uses `IEnumOnSTLImpl`)|  
 |[CComEnum](../atl/reference/ccomenum-class.md)|Enumerator object implementation (uses `CComEnumImpl`)|  
 |[_Copy](../atl/atl-copy-policy-classes.md)|Copy policy class|  
 |[_CopyInterface](../atl/atl-copy-policy-classes.md)|Copy policy class|  
-|[CAdapt](../atl/reference/cadapt-class.md)|Adapter class (hides **operator &** allowing `CComPtr`, `CComQIPtr`, and `CComBSTR` to be stored in STL containers)|  
+|[CAdapt](../atl/reference/cadapt-class.md)|Adapter class (hides **operator &** allowing `CComPtr`, `CComQIPtr`, and `CComBSTR` to be stored in C++ Standard Library containers)|  
 
 ## See Also  
  [Collections and Enumerators](../atl/atl-collections-and-enumerators.md)

docs/atl/atl-collections-and-enumerators.md

@@ -51,8 +51,8 @@ A `collection` is a COM object that provides an interface that allows access to
  [Design Principles for Collection and Enumerator Interfaces](../atl/design-principles-for-collection-and-enumerator-interfaces.md)  
  Discusses the different design principles behind each type of interface.  
 
- [Implementing an STL-Based Collection](../atl/implementing-an-stl-based-collection.md)  
- An extended example that walks you through the implementation of a Standard Template Library (STL)-based collection.  
+ [Implementing a C++ Standard Library-Based Collection](../atl/implementing-an-stl-based-collection.md)  
+ An extended example that walks you through the implementation of a C++ Standard Library-based collection.  
 
 ## Related Sections  
  [ATL](../atl/active-template-library-atl-concepts.md)  

docs/atl/atl-com-desktop-components.md

@@ -78,5 +78,5 @@ The ATL Reference documents the Active Template Library (ATL), a set of template
  Provides reference material for the OLE DB consumer and provider templates, a set of template classes that implement many commonly used OLE DB interfaces.  
 
  [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.
 

docs/atl/atl-copy-policy-classes.md

@@ -90,11 +90,11 @@ Copy policy classes are [utility classes](../atl/utility-classes.md) used to ini
  VCUE_Copy.h also contains the following specializations of this class: `GenericCopy<BSTR>`, `GenericCopy<VARIANT, BSTR>`, `GenericCopy<BSTR, VARIANT>`. VCUE_CopyString.h contains specializations for copying from **std::string**s: `GenericCopy<std::string>`, `GenericCopy<VARIANT, std::string>`, and `GenericCopy<BSTR, std::string>`. You could enhance `GenericCopy` by providing further specializations of your own.  
 
 ### MapCopy  
- `MapCopy` assumes that the data being copied is stored into an STL-style map, so it allows you to specify the type of map in which the data is stored and the destination type. The implementation of the class just uses the typedefs supplied by the *MapType* class to determine the type of the source data and to call the appropriate `GenericCopy` class. No specializations of this class are needed.  
+ `MapCopy` assumes that the data being copied is stored into a C++ Standard Library-style map, so it allows you to specify the type of map in which the data is stored and the destination type. The implementation of the class just uses the typedefs supplied by the *MapType* class to determine the type of the source data and to call the appropriate `GenericCopy` class. No specializations of this class are needed.  
 
  [!code-cpp[NVC_ATL_COM#31](../atl/codesnippet/cpp/atl-copy-policy-classes_2.h)]  
 
 ## See Also  
- [Implementing an STL-Based Collection](../atl/implementing-an-stl-based-collection.md)   
+ [Implementing a C++ Standard Library-Based Collection](../atl/implementing-an-stl-based-collection.md)   
  [ATLCollections Sample](../visual-cpp-samples.md)
 

docs/atl/enumerators-and-collections-classes.md

@@ -41,9 +41,9 @@ The following classes provide support for COM collections and enumerations:
 
 -   [CComEnumImpl](../atl/reference/ccomenumimpl-class.md) Provides the implementation for a COM enumerator interface where the items being enumerated are stored in an array.  
 
--   [CComEnumOnSTL](../atl/reference/ccomenumonstl-class.md) Defines a COM enumerator object based on an STL collection.  
+-   [CComEnumOnSTL](../atl/reference/ccomenumonstl-class.md) Defines a COM enumerator object based on a C++ Standard Library collection.  
 
--   [IEnumOnSTLImpl](../atl/reference/ienumonstlimpl-class.md) Provides the implementation for a COM enumerator interface where the items being enumerated are stored in an STL-compatible container.  
+-   [IEnumOnSTLImpl](../atl/reference/ienumonstlimpl-class.md) Provides the implementation for a COM enumerator interface where the items being enumerated are stored in a C++ Standard Library-compatible container.  
 
 -   [ICollectionOnSTLImpl](../atl/reference/icollectiononstlimpl-class.md) Provides the implementation for the **Count**, **Item**, and `_NewEnum` properties of a collection interface.  
 

docs/atl/implementing-an-stl-based-collection.md

@@ -1,5 +1,5 @@
 ---
-title: "Implementing an STL-Based Collection | Microsoft Docs"
+title: "Implementing a C++ Standard Library-Based Collection | Microsoft Docs"
 ms.custom: ""
 ms.date: "11/04/2016"
 ms.reviewer: ""
@@ -32,8 +32,8 @@ translation.priority.ht:
   - "zh-cn"
   - "zh-tw"
 ---
-# Implementing an STL-Based Collection
-ATL provides the `ICollectionOnSTLImpl` interface to enable you to quickly implement Standard Template Library (STL)-based collection interfaces on your objects. To understand how this class works, you will work through a simple example (below) that uses this class to implement a read-only collection aimed at Automation clients.  
+# Implementing a C++ Standard Library-Based Collection
+ATL provides the `ICollectionOnSTLImpl` interface to enable you to quickly implement C++ Standard Library-based collection interfaces on your objects. To understand how this class works, you will work through a simple example (below) that uses this class to implement a read-only collection aimed at Automation clients.  
 
  The sample code is from the [ATLCollections sample](../visual-cpp-samples.md).  
 
@@ -82,7 +82,7 @@ ATL provides the `ICollectionOnSTLImpl` interface to enable you to quickly imple
 
  [!code-cpp[NVC_ATL_COM#25](../atl/codesnippet/cpp/implementing-an-stl-based-collection_2.h)]  
 
- In this case, you will store the data as a **std::vector** of **std::string**s. **std::vector** is an STL container class that behaves like a managed array. **std::string** is the Standard C++ Library's string class. These classes make it easy to work with a collection of strings.  
+ In this case, you will store the data as a **std::vector** of **std::string**s. **std::vector** is a C++ Standard Library container class that behaves like a managed array. **std::string** is the C++ Standard Library's string class. These classes make it easy to work with a collection of strings.  
 
  Since Visual Basic support is vital to the success of this interface, the enumerator returned by the `_NewEnum` property must support the **IEnumVARIANT** interface. This is the only enumerator interface understood by Visual Basic.  
 

docs/atl/introduction-to-atl.md

@@ -40,7 +40,7 @@ ATL is the Active Template Library, a set of template-based C++ classes with whi
 
  Topics covered in this section include:  
 
--   How a [template library](../atl/using-a-template-library.md) differs from a standard C++ library.  
+-   How a [template library](../atl/using-a-template-library.md) differs from a standard library.  
 
 -   What you [can and cannot do with ATL](../atl/scope-of-atl.md).  
 

docs/atl/reference/atl-classes.md

@@ -97,7 +97,7 @@ The Active Template Library (ATL) includes the following classes. To find a part
 |[CComDynamicUnkArray](../../atl/reference/ccomdynamicunkarray-class.md)|This class stores an array of **IUnknown** pointers.|atlcom.h|  
 |[CComEnum](../../atl/reference/ccomenum-class.md)|This class defines a COM enumerator object based on an array.|atlcom.h|  
 |[CComEnumImpl](../../atl/reference/ccomenumimpl-class.md)|This class provides the implementation for a COM enumerator interface where the items being enumerated are stored in an array.|atlcom.h|  
-|[CComEnumOnSTL](../../atl/reference/ccomenumonstl-class.md)|This class defines a COM enumerator object based on an STL collection.|atlcom.h|  
+|[CComEnumOnSTL](../../atl/reference/ccomenumonstl-class.md)|This class defines a COM enumerator object based on a C++ Standard Library collection.|atlcom.h|  
 |[CComFakeCriticalSection](../../atl/reference/ccomfakecriticalsection-class.md)|This class provides the same methods as [CComCriticalSection](../../atl/reference/ccomcriticalsection-class.md) but does not provide a critical section.|atlcore.h|  
 |[CComGITPtr](../../atl/reference/ccomgitptr-class.md)|This class provides methods for dealing with interface pointers and the global interface table (GIT).|atlbase.h|  
 |[CComHeap](../../atl/reference/ccomheap-class.md)|This class implements [IAtlMemMgr](../../atl/reference/iatlmemmgr-class.md) using the COM memory allocation functions.|ATLComMem.h|  
@@ -203,7 +203,7 @@ The Active Template Library (ATL) includes the following classes. To find a part
 |[IDispEventImpl](../../atl/reference/idispeventimpl-class.md)|This class provides implementations of the `IDispatch` methods.|atlcom.h|  
 |[IDispEventSimpleImpl](../../atl/reference/idispeventsimpleimpl-class.md)|This class provides implementations of the `IDispatch` methods, without getting type information from a type library.|atlcom.h|  
 |[IDocHostUIHandlerDispatch](../../atl/reference/idochostuihandlerdispatch-interface.md)|An interface to the Microsoft HTML parsing and rendering engine.|atlbase.h, ATLIFace.h|  
-|[IEnumOnSTLImpl](../../atl/reference/ienumonstlimpl-class.md)|This class defines an enumerator interface based on an STL collection.|atlcom.h|  
+|[IEnumOnSTLImpl](../../atl/reference/ienumonstlimpl-class.md)|This class defines an enumerator interface based on a C++ Standard Library collection.|atlcom.h|  
 |[IObjectSafetyImpl](../../atl/reference/iobjectsafetyimpl-class.md)|This class provides a default implementation of the `IObjectSafety` interface to allow a client to retrieve and set an object's safety levels.|atlctl.h|  
 |[IObjectWithSiteImpl](../../atl/reference/iobjectwithsiteimpl-class.md)|This class provides methods allowing an object to communicate with its site.|atlcom.h|  
 |[IOleControlImpl](../../atl/reference/iolecontrolimpl-class.md)|This class provides a default implementation of the **IOleControl** interface and implements **IUnknown**.|atlctl.h|