Update to address cpp-docs 4117 (#4485)

* Update to address cpp-docs 4117

* Fix a typo.

Author: colin-home

docs/c-language/inline-functions.md

@@ -1,15 +1,13 @@
 ---
 description: "Learn more about: Inline Functions"
 title: "Inline Functions"
-ms.date: 05/17/2022
+ms.date: 08/24/2022
 helpviewer_keywords: ["fast code", "inline functions, __inline keyword", "functions [C++], inline functions"]
 ms.assetid: 00f4b2ff-8ad0-4165-9f4c-2ef157d03f31
 ---
 # Inline functions
 
-**Microsoft specific**
-
-The **`__inline`** keyword tells the compiler to substitute the code within the function definition for every instance of a function call.
+The **`inline`** keyword is a function specifier that tells the compiler to substitute the code within the function definition for every instance of a function call.
 
 ## Remarks
 
@@ -19,7 +17,7 @@ For a function to be considered as a candidate for inlining, it must use the new
 
 Use this form to specify an inline function:
 
-> **`__inline`** *function-definition*
+> **`inline`** *function-definition*
 
 Inline functions generate faster and sometimes smaller code than the equivalent function call:
 
@@ -29,7 +27,13 @@ Inline functions generate faster and sometimes smaller code than the equivalent
 
 - The compiler can optimize functions generated inline in ways that aren't available to normal functions. The compiler doesn't usually perform optimizations between different procedures.
 
-Don't confuse functions that use **`__inline`** with inline assembler code. For more information about inline assembler, see [Inline assembler](../c-language/inline-assembler-c.md).
+Don't confuse functions that use **`inline`** with inline assembler code. For more information about inline assembler, see [Inline assembler](../c-language/inline-assembler-c.md).
+
+**Microsoft specific**
+
+Microsoft also supports **`__inline`** and **`__forceinline`** keywords to tell the compiler to substitute the code within the function definition for every instance of a function call. The **`__inline`** keyword is a synonym for **`inline`**. The **`__forceinline`** keyword tells the compiler to relax the heuristics on whether to inline the function, though it doesn't guarantee a function will be inlined.
+
+For compatibility with previous versions, **`_inline`** and **`_forceinline`** are synonyms for **`__inline`** and **`__forceinline`**, respectively, unless compiler option [`/Za` \(Disable language extensions)](../build/reference/za-ze-disable-language-extensions.md) is specified.
 
 **END Microsoft specific**
 

docs/cpp/inline-functions-cpp.md

@@ -1,7 +1,7 @@
 ---
 title: "Inline Functions (C++)"
 description: "The C++ inline keyword can be used to suggest inline functions to the compiler."
-ms.date: 05/17/2022
+ms.date: 08/24/2022
 f1_keywords: ["__forceinline_cpp", "__inline_cpp", "inline_cpp", "__inline", "_inline", "__forceinline", "_forceinline"]
 helpviewer_keywords: ["inline functions [C++], class members"]
 ms.assetid: 355f120c-2847-4608-ac04-8dda18ffe10c
@@ -57,7 +57,7 @@ int main()
 
 A given inline member function must be declared the same way in every compilation unit. This constraint causes inline functions to behave as if they were instantiated functions. Additionally, there must be exactly one definition of an inline function.
 
-A class member function defaults to external linkage unless a definition for that function contains the **`inline`** specifier. The preceding example shows that you don't have to declare these functions explicitly with the **`inline`** specifier. Using **`inline`** in the function definition causes it to be an inline function. However, it's not allowed to redeclare a function as **`inline`** after a call to that function.
+A class member function defaults to external linkage unless a definition for that function contains the **`inline`** specifier. The preceding example shows that you don't have to declare these functions explicitly with the **`inline`** specifier. Using **`inline`** in the function definition causes it to be an inline function. However, you can't redeclare a function as **`inline`** after a call to that function.
 
 ## `inline`, `__inline`, and `__forceinline`
 
@@ -67,9 +67,9 @@ The insertion, called *inline expansion* or *inlining*, occurs only if the compi
 
 The **`__forceinline`** keyword overrides the cost-benefit analysis and relies on the judgment of the programmer instead. Exercise caution when using **`__forceinline`**. Indiscriminate use of **`__forceinline`** can result in larger code with only marginal performance gains or, in some cases, even performance losses (because of the increased paging of a larger executable, for example).
 
-The compiler treats the inline expansion options and keywords as suggestions. There's no guarantee that functions will be inlined. You can't force the compiler to inline a particular function, even with the **`__forceinline`** keyword. When compiling with **`/clr`**, the compiler won't inline a function if there are security attributes applied to the function.
+The compiler treats the inline expansion options and keywords as suggestions. There's no guarantee that functions will be inlined. You can't force the compiler to inline a particular function, even with the **`__forceinline`** keyword. When you compile with **`/clr`**, the compiler won't inline a function if there are security attributes applied to the function.
 
-The **`inline`** keyword is available only in C++. The **`__inline`** and **`__forceinline`** keywords are available in both C and C++. For compatibility with previous versions, **`_inline`** and **`_forceinline`** are synonyms for **`__inline`**, and **`__forceinline`** unless compiler option [`/Za` \(Disable language extensions)](../build/reference/za-ze-disable-language-extensions.md) is specified.
+For compatibility with previous versions, **`_inline`** and **`_forceinline`** are synonyms for **`__inline`** and **`__forceinline`**, respectively, unless compiler option [`/Za` \(Disable language extensions)](../build/reference/za-ze-disable-language-extensions.md) is specified.
 
 The **`inline`** keyword tells the compiler that inline expansion is preferred. However, the compiler can create a separate instance of the function (instantiate) and create standard calling linkages instead of inserting the code inline. Two cases where this behavior can happen are: