@@ -91,16 +91,17 @@ errno_t wmemcpy_s(
 
 ### Error Conditions  
 
-|`dest`|`destSize`|`src`|Return value|Contents of `dest`|  
-|------------|----------------|-----------|------------------|------------------------|  
-|`NULL`|any|any|`EINVAL`|not modified|  
-|any|any|`NULL`|`EINVAL`|`dest` is zeroed out|  
-|any|< `count`|any|`ERANGE`|`dest` is zeroed out|  
+|`dest`|`destSize`|`src`|`count`|Return value|Contents of `dest`|  
+|------------|----------------|-----------|---|------------------|------------------------|  
+|any|any|any|0|0|Not modified|  
+|`NULL`|any|any|non-zero|`EINVAL`|Not modified|  
+|any|any|`NULL`|non-zero|`EINVAL`|`dest` is zeroed out|  
+|any|< `count`|any|non-zero|`ERANGE`|`dest` is zeroed out|  
 
 ## Remarks  
  `memcpy_s` copies `count` bytes from `src` to `dest`; `wmemcpy_s` copies `count` wide characters (two bytes). If the source and destination overlap, the behavior of `memcpy_s` is undefined. Use `memmove_s` to handle overlapping regions.  
 
- These functions validate their parameters. If `dest` or `src` is a null pointer, or `destSize` is smaller than `count`, these functions invoke the invalid parameter handler, as described in [Parameter Validation](../../c-runtime-library/parameter-validation.md). If execution is allowed to continue, these functions return `EINVAL` and set `errno` to `EINVAL`.  
+ These functions validate their parameters. If `count` is non-zero and `dest` or `src` is a null pointer, or `destSize` is smaller than `count`, these functions invoke the invalid parameter handler, as described in [Parameter Validation](../../c-runtime-library/parameter-validation.md). If execution is allowed to continue, these functions return `EINVAL` or `ERANGE` and set `errno` to the return value.  
 
 ## Requirements  
 
 
@@ -162,7 +162,11 @@ private:
 
 -   The function is also marked with the [naked](../cpp/naked-cpp.md) [__declspec](../cpp/declspec.md) modifier.  
 
- If the compiler cannot inline a function declared with `__forceinline`, it generates a level 1 warning.  
+ If the compiler cannot inline a function declared with `__forceinline`, it generates a level 1 warning, except when:
+  
+-   The function is compiled by using /Od or /Ob0. No inlining is expected in these cases.     
+  
+-   The function is defined externally, in an included library or another translation unit, or is a virtual call target or indirect call target. The compiler can't identify non-inlined code that it can't find in the current translation unit.  
 
  Recursive functions can be substituted inline to a depth specified by the [inline_depth](../preprocessor/inline-depth.md) pragma, up to a maximum of 16 calls. After that depth, recursive function calls are treated as calls to an instance of the function.  The depth to which recursive functions are examined by the inline heuristic cannot exceed 16. The [inline_recursion](../preprocessor/inline-recursion.md) pragma controls the inline expansion of a function currently under expansion. See the [Inline-Function Expansion](../build/reference/ob-inline-function-expansion.md) (/Ob) compiler option for related information.  
 
 
@@ -33,7 +33,9 @@ translation.priority.ht:
   - "zh-cn"
   - "zh-tw"
 ---
+
 # Porting third-party libraries
+
 When you upgrade a project to the current version of Visual C++, you also have to upgrade any libraries that the project uses, so that the library and your project are built with the same version and flavor of the compiler. (For more information, see [Overview of potential upgrade issues](overview-of-potential-upgrade-issues-visual-cpp.md)). 
 
 ## Introducing vcpkg
 
@@ -92,7 +92,7 @@ This topic provides a guide for upgrading Visual C++ code. This includes getting
 
 |Title|Description|  
 |-----------|-----------------|  
-|[Upgrading Projects from Earlier Versions of Visual C++](upgrading-projects-from-earlier-versions-of-visual-cpp.md)|Discusses how to use projects created in earlier versions of Visual C++.|  
+ |[Upgrading Projects from Earlier Versions of Visual C++](upgrading-projects-from-earlier-versions-of-visual-cpp.md)|Discusses how to use projects created in earlier versions of Visual C++.|  
 |[What's New for Visual C++ in Visual Studio 2017 RC](what-s-new-for-visual-cpp-in-visual-studio.md)|Changes in the IDE and tools from Visual Studio 2015 to Visual Studio 2017|
 |[C++ conformance improvements in Visual Studio 2017](cpp-conformance-improvements-2017.md)|Standards conformance improvements from Visual Studio 2015 to Visual Studio 2017|
 |[Visual C++ change history 2003 - 2015](visual-cpp-change-history-2003-2015.md)|A list of all the changes in the Visual C++ libraries and build tools from Visual Studio 2003 through 2015 that might require changes in your code.|  
@@ -101,7 +101,7 @@ This topic provides a guide for upgrading Visual C++ code. This includes getting
 |[Porting and Upgrading: Examples and Case Studies](porting-and-upgrading-examples-and-case-studies.md)|For this section, we ported and upgrades several samples and applications and discussed the experiences and results. You might find that reading these gives you a sense of what is involved in the porting and upgrading process. Throughout the process, we discuss tips and tricks for upgrading and show how specific errors were fixed.|  
 |[Porting to the Universal Windows Platform](porting-to-the-universal-windows-platform-cpp.md)|Contains information about porting code to Windows 10|  
 |[Introduction to Visual C++ for UNIX Users](introduction-to-visual-cpp-for-unix-users.md)|Provides information for UNIX users who are new to [!INCLUDE[vcprvc](../build/includes/vcprvc_md.md)] and want to become productive with it.|  
-|[Porting from UNIX to Win32](porting-from-unix-to-win32.md)|Discusses options for migrating UNIX applications to Windows.|  
+|[Porting from UNIX to Win32](porting-from-unix-to-win32.md)|Discusses options for migrating UNIX applications to Windows.| 
 |[C++/CLI Migration Primer](../dotnet/cpp-cli-migration-primer.md)|Shows in detail how to upgrade your Managed Extensions for C++ syntax to use the new syntax. For more information, see [Component Extensions for Runtime Platforms](../windows/component-extensions-for-runtime-platforms.md).|  
 
 ## See Also  
 
@@ -106,7 +106,6 @@ invoked const volatile S.f()
 
 ## Requirements  
 **Header:** \<type_traits>  
-  
 **Namespace:** std  
 
 ## See Also  
 
@@ -80,6 +80,7 @@ add_volatile<int> == int
 ```  
 
 ## Requirements  
+
 **Header:** \<type_traits>  
 
 **Namespace:** std  
 
@@ -267,8 +267,6 @@ virtual pos_type seekpos(pos_type _Sp, ios_base::openmode _Mode = ios_base::in |
 
 ```  
 basic_string<Elem, Tr, Alloc> str() const;
-
- 
 void str(
     const basic_string<Elem, Tr, Alloc>& _Newstr);
 ```  
@@ -349,7 +347,7 @@ virtual int_type underflow();
 ##  <a name="basic_streambuf__swap"></a>  basic_streambuf::swap  
  Swaps the contents of this string buffer with another string buffer.  
 
-```cpp  
+```  
 void basic_stringbuf<T>::swap(basic_stringbuf& other)  
 ```  
 
@@ -360,13 +358,10 @@ void basic_stringbuf<T>::swap(basic_stringbuf& other)
 ### Remarks  
 
 ##  <a name="basic_stringbuf__operator_eq"></a>  basic_stringbuf::operator=  
- Assigns the contents of the basic_stringbuf on the right side of the operator to the basic_stringbuf on the left side..  
-  
-```cpp  
-basic_stringbuf& basic_stringbuf:: operator=(const basic_stringbuf& other)  
-```  
+ Assigns the contents of the basic_stringbuf on the right side of the operator to the basic_stringbuf on the left side.  
 
 ```  
+basic_stringbuf& basic_stringbuf:: operator=(const basic_stringbuf& other)  
 ```  
 
 ### Parameters  
 
@@ -92,7 +92,7 @@ class fpos
  Create an object that contains information about a position (offset) in a stream.  
 
 ```  
-fpos(streamoff _Off =0);
+fpos(streamoff _Off = 0);
 
 fpos(Statetype _State, fpos_t _Filepos);
 ```  
@@ -226,7 +226,6 @@ fpos<Statetype>& operator+=(streamoff _Off);
   
 ```  
 streamoff operator-(const fpos<Statetype>& right) const;
-
 
 fpos<Statetype> operator-(streamoff _Off) const;
 ```  
@@ -287,7 +286,8 @@ bool operator==(const fpos<Statetype>& right) const;
 ##  <a name="fpos__operator_streamoff"></a>  fpos::operator streamoff  
  Cast object of type `fpos` to object of type `streamoff`.  
   
-```  operator streamoff() const;
+```  
+operator streamoff() const;
 ```  
   
 ### Remarks  
 
@@ -52,46 +52,42 @@ public:
 
     function();
     function(nullptr_t);
-
     function(const function& right);
-
     template <class Fty2>
-    function(Fty2 fn);
-
+        function(Fty2 fn);
     template <class Fty2, class Alloc>
-    function(reference_wrapper<Fty2>, const Alloc& Ax);
+        function(reference_wrapper<Fty2>, const Alloc& Ax);
 
     template <class Fty2, class Alloc>
-    void assign(Fty2, const Alloc& Ax);
-
+        void assign(Fty2, const Alloc& Ax);
     template <class Fty2, class Alloc>
-    assign(reference_wrapper<Fty2>, const Alloc& Ax);
+        void assign(reference_wrapper<Fty2>, const Alloc& Ax);
     function& operator=(nullptr_t);
     function& operator=(const function&);
     template <class Fty2>
-    function& operator=(Fty2);
+        function& operator=(Fty2);
     template <class Fty2>
-    function& operator=(reference_wrapper<Fty2>);
+        function& operator=(reference_wrapper<Fty2>);
 
     void swap(function&);
     explicit operator bool() const;
 
     result_type operator()(T1, T2, ....., TN) const;
     const std::type_info& target_type() const;
     template <class Fty2>
-    Fty2 *target();
+        Fty2 *target();
 
     template <class Fty2>
-    const Fty2 *target() const;
+        const Fty2 *target() const;
 
     template <class Fty2>
-    void operator==(const Fty2&) const = delete;
+        void operator==(const Fty2&) const = delete;
     template <class Fty2>
-    void operator!=(const Fty2&) const = delete;
+        void operator!=(const Fty2&) const = delete;
 };
 ```  
 
-#### Parameters  
+### Parameters  
  `Fty`  
  The function type to wrap.  
 
@@ -154,15 +150,14 @@ public:
 
 ```  
 template <class Fx, class Alloc>  
-void assign(
-    Fx _Func,   
-    const Alloc& Ax);
+    void assign(
+        Fx _Func,   
+        const Alloc& Ax);
 
 template <class Fx, class Alloc>  
-void assign(
-    reference_wrapper<Fx>  
-_Fnref,   
-    const Alloc& Ax);
+    void assign(
+        reference_wrapper<Fx> _Fnref,   
+        const Alloc& Ax);
 ```  
 
 ### Parameters  
@@ -183,41 +178,34 @@ _Fnref,
 
 ```  
 function();
-
 function(nullptr_t npc);
-
 function(const function& right);
-
 template <class Fx>  
-function(Fx _Func);
-
+    function(Fx _Func);
 template <class Fx>  
-function(reference_wrapper<Fx>  
-_Fnref);
-
+    function(reference_wrapper<Fx> _Fnref);
 template <class Fx, class Alloc>  
-function(
- Fx _Func,   
-    const Alloc& Ax);
+    function(
+        Fx _Func,   
+        const Alloc& Ax);
 
 template <class Fx, class Alloc>  
-function(
- reference_wrapper<Fx>  
-_Fnref,   
-    const Alloc& Ax);
+    function(
+        reference_wrapper<Fx> _Fnref,   
+        const Alloc& Ax);
 ```  
 
 ### Parameters  
  ` right`  
  The function object to copy.  
 
- Fx  
+ `Fx`  
  The type of the callable object.  
 
  `_Func`  
  The callable object to wrap.  
 
- Alloc  
+ `Alloc`  
  The allocator type.  
 
  `Ax`  
@@ -302,7 +290,8 @@ g is empty (correct).
 ##  <a name="function__operator_unspecified"></a>  function::operator unspecified  
  Tests if stored callable object exists.  
 
-```  operator unspecified();
+```  
+operator unspecified();
 ```   
 
 ### Remarks  
@@ -330,8 +319,7 @@ int main()
     std::cout << std::boolalpha << "not empty == " << (bool)fn1 << std::endl;   
 
     return (0);   
-    }  
-  
+    }    
 ```  
   
 ```Output  
@@ -343,7 +331,8 @@ not empty == true
  Calls a callable object.  
 
 ```  
-result_type operator()(T1 t1,
+result_type operator()(
+    T1 t1,
     T2 t2, ...,
     TN tN);
 ```  
@@ -379,7 +368,6 @@ int main()
 
     return (0);   
     }  
-  
 ```  
   
 ```Output  
@@ -392,15 +380,11 @@ val == -3
 
 ```  
 function& operator=(null_ptr_type npc);
-
 function& operator=(const function& right);
-
 template <class Fty>  
-function& operator=(Fty fn);
-
+    function& operator=(Fty fn);
 template <class Fty>  
-function& operator=(reference_wrapper<Fty>  
-fnref);
+    function& operator=(reference_wrapper<Fty> fnref);
 ```  
 
 ### Parameters  
@@ -456,7 +440,6 @@ int main()
 
     return (0);   
     }  
-  
 ```  
   
 ```Output  
@@ -504,7 +487,6 @@ int main()
 
     return (0);   
     }  
-  
 ```  
   
 ```Output  
@@ -556,7 +538,6 @@ int main()
 
     return (0);   
     }  
-  
 ```  
   
 ```Output  
@@ -574,10 +555,9 @@ val == -3
 
 ```  
 template <class Fty2>  
-Fty2 *target();
-
+    Fty2 *target();
 template <class Fty2>  
-const Fty2 *target() const;
+    const Fty2 *target() const;
 ```  
 
 ### Parameters  
@@ -664,7 +644,6 @@ int main()
 
     return (0);   
     }  
-  
 ```  
   
 ```Output