Add "Remarks" and "Example" headings for warning references in range [C4701, C4750]

Rageking8 · web-flow · commit cea02c8a9a45 · 2025-09-02T17:08:54.000+08:00
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-c4746.md b/docs/error-messages/compiler-warnings/compiler-warning-c4746.md
@@ -10,6 +10,8 @@ ms.assetid: 5e79ab46-6031-499a-a986-716c866b6c0e
 
 > volatile access of '\<expression>' is subject to /volatile:[iso\|ms] setting; consider using __iso_volatile_load/store intrinsic functions.
 
+## Remarks
+
 C4746 is emitted whenever a volatile variable is accessed directly. It's intended to help developers identify code locations that are affected by the specific volatile model currently specified (which can be controlled with the [`/volatile`](../../build/reference/volatile-volatile-keyword-interpretation.md) compiler option). In particular, it can be useful in locating compiler-generated hardware memory barriers when `/volatile:ms` is used.
 
 The __iso_volatile_load/store intrinsics can be used to explicitly access volatile memory without being affected by the volatile model. Using these intrinsics will not trigger C4746.
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4711.md b/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4711.md
@@ -10,6 +10,8 @@ ms.assetid: 270506ab-fead-4328-b714-2978113be238
 
 > function 'function' selected for inline expansion
 
+## Remarks
+
 The compiler performed inlining on the given function, although it was not marked for inlining.
 
 C4711 is enabled if [/Ob2](../../build/reference/ob-inline-function-expansion.md) is specified.
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4715.md b/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4715.md
@@ -10,6 +10,8 @@ ms.assetid: 1c819bf7-0d8b-4f5e-b338-9cc292870439
 
 > 'function' : not all control paths return a value
 
+## Remarks
+
 The specified function can potentially not return a value.
 
 ## Example
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4716.md b/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4716.md
@@ -10,6 +10,8 @@ ms.assetid: d95ecfe5-870f-461f-a746-7913af98414b
 
 > 'function' must return a value
 
+## Remarks
+
 The given function did not return a value.
 
 Only functions with a return type of void can use the return command without an accompanying return value.
@@ -18,6 +20,8 @@ An undefined value will be returned when this function is called.
 
 This warning is automatically promoted to an error. If you wish to modify this behavior, use [#pragma warning](../../preprocessor/warning.md).
 
+## Example
+
 The following sample generates C4716:
 
 ```cpp
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4717.md b/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4717.md
@@ -10,8 +10,12 @@ ms.assetid: 5ef3c6c7-8599-4714-a973-0f5b69cdab3c
 
 > 'function' : recursive on all control paths, function will cause runtime stack overflow
 
+## Remarks
+
 Every path through a function contains a call to the function. Since there is no way to exit the function without first calling itself recursively, the function will never exit.
 
+## Example
+
 The following sample generates C4717:
 
 ```cpp
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4722.md b/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4722.md
@@ -9,6 +9,8 @@ helpviewer_keywords: ["C4722"]
 
 > 'function' : destructor never returns, potential memory leak
 
+## Remarks
+
 The flow of control terminates in a destructor. The thread or the entire program will terminate and allocated resources may not be released.  Furthermore, if a destructor will be called for stack unwinding during exception processing, the behavior of executable is undefined.
 
 To resolve, remove the function call that causes the destructor to not return.
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4727.md b/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4727.md
@@ -10,13 +10,17 @@ ms.assetid: 991b0087-3a50-40f5-9cdb-cdc367cd472c
 
 > "PCH named pch_file with same timestamp found in obj_file_1 and obj_file_2.  Using first PCH.
 
+## Remarks
+
 > [!NOTE]
 > In Visual Studio 2017 and earlier, the precompiled header is called *stdafx.h* by default, and in Visual Studio 2019 and later, it is called *pch.h* by default.
 
 C4727 occurs when compiling multiple compilands with **/Yc**, and where the compiler was able to mark all .obj files with the same .pch timestamp.
 
 To resolve, compile one source file with **/Yc /c** (creates pch), and the others compile separately with **/Yu /c** (uses pch), then link them together.
 
+## Example
+
 So, if you did the following and it generates C4727:
 
 ::: moniker range="<=msvc-150"
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4729.md b/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4729.md
@@ -10,6 +10,8 @@ ms.assetid: 36a0151f-f258-48d9-9444-ae6d41ff70a4
 
 > function too big for flow graph based warnings
 
+## Remarks
+
 This warning is generated when a function is too big to be compiled with reliable checking for situations that would generate a warning. This warning is only generated when the [/Od](../../build/reference/od-disable-debug.md) compiler option used.
 
 To resolve this warning, break the function into smaller functions.
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4730.md b/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4730.md
@@ -10,10 +10,14 @@ ms.assetid: 11303e3f-162b-4b19-970a-479686123a68
 
 > 'main' : mixing _m64 and floating point expressions may result in incorrect code
 
+## Remarks
+
 A function uses [__m64](../../cpp/m64.md) and **`float`**/**`double`** types. Because the MMX and floating-point registers share the same physical register space (cannot be used simultaneously), using **`__m64`** and **`float`**/**`double`** types in the same function can result in data corruption, possibly causing an exception.
 
 To safely use **`__m64`** types and floating-point types in the same function, each instruction that uses one of the types should be separated by the **_m_empty()** (for MMX) or **_m_femms()** (for 3DNow!) intrinsic.
 
+## Example
+
 The following sample generates C4730:
 
 ```cpp
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4731.md b/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4731.md
@@ -10,8 +10,12 @@ ms.assetid: 5658c24c-3e6f-4505-835b-1fb92d47cab0
 
 > 'pointer' : frame pointer register 'register' modified by inline assembly code
 
+## Remarks
+
 A frame pointer register was modified. You must save and restore the register in your inline assembly block or frame variable (local or parameter, depending on the register modified), or your code may not work properly.
 
+## Example
+
 The following sample generates C4731:
 
 ```cpp
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4733.md b/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4733.md
@@ -10,10 +10,14 @@ ms.assetid: 7ef4f577-772d-4b66-a7bf-8958a6b250bc
 
 > Inline asm assigning to 'FS:0' : handler not registered as safe handler
 
+## Remarks
+
 A function modifying the value at FS:0 to add a new exception handler may not work with Safe Exceptions, because the handler may not be registered as a valid exception handler (see [/SAFESEH](../../build/reference/safeseh-image-has-safe-exception-handlers.md)).
 
 To resolve this warning, either remove the FS:0 definition or turn off this warning and use [.SAFESEH](../../assembler/masm/dot-safeseh.md) to specify the safe exception handlers.
 
+## Example
+
 The following sample generates C4733:
 
 ```cpp
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4739.md b/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4739.md
@@ -10,10 +10,14 @@ ms.assetid: 600873b3-7c85-4cd4-944e-cd8e01bfcbb0
 
 > reference to variable 'var' exceeds its storage space
 
+## Remarks
+
 A value was assigned to a variable, but the value is greater than the size of the variable. Memory will be written beyond the variable's memory location, and data loss is possible.
 
 To resolve this warning, only assign a value to a variable whose size can accommodate the value.
 
+## Example
+
 The following sample generates C4739:
 
 ```cpp
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4742.md b/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4742.md
@@ -10,10 +10,10 @@ ms.assetid: e520881d-1eeb-48b1-9df0-8017ee8ba076
 
 > '*variable*' has different alignment in '*file1*' and '*file2*': *number1* and *number2*
 
-An external variable that was referenced or defined in two files has different alignment in those files.
-
 ## Remarks
 
+An external variable that was referenced or defined in two files has different alignment in those files.
+
 This warning is emitted when compiler finds that **`alignof`** for the variable in *file1* differs from **`alignof`** for the variable in *file2*. This can be caused by using incompatible types when declaring variable in different files, or by using non-matching `#pragma pack` in different files.
 
 To resolve this warning, either use the same type definition or use different names for the variables.
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4743.md b/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4743.md
@@ -10,10 +10,10 @@ ms.assetid: 2ee76ea3-77f3-4c2f-9a57-0751823c89fd
 
 > '*type*' has different size in '*file1*' and '*file2*': *size_1* and *size_2* bytes
 
-An external variable referenced or defined in two files has different types in those files, and the compiler determined that the size of the variable in *file1* differs from the size of the variable in *file2*.
-
 ## Remarks
 
+An external variable referenced or defined in two files has different types in those files, and the compiler determined that the size of the variable in *file1* differs from the size of the variable in *file2*.
+
 There's an important case when this warning can be emitted for C++. If you declare class types with the same name in two different files, if those declarations contain virtual functions, and if the declarations aren't the same, then the compiler can emit warning C4744 for the virtual function tables. The warning occurs because there are two different-sized virtual function tables for the same type, and the linker must choose one of them to incorporate into the executable.  It's possible that it can result in your program calling the wrong virtual function.
 
 To resolve this warning, either use the same type definition or use different names for the types or variables.
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4744.md b/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4744.md
@@ -9,14 +9,16 @@ helpviewer_keywords: ["C4744"]
 
 > 'var' has different type in 'file1' and 'file2': 'type1' and 'type2'
 
+## Remarks
+
 An external variable referenced or defined in two files has different types in those files.  To resolve, either make the type definitions the same, or change variable name in one of the files.
 
 C4744 is emitted only when files are compiled with /GL.  For more information, see [/GL (Whole Program Optimization)](../../build/reference/gl-whole-program-optimization.md).
 
 > [!NOTE]
 > C4744 usually occurs in C (not C++) files, because in C++ a variable name is decorated with type information.  When the sample (below) is compiles as C++, you'll get linker error LNK2019.
 
-## Examples
+## Example
 
 This sample contains the first definition.
 
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4747.md b/docs/error-messages/compiler-warnings/compiler-warning-level-1-c4747.md
@@ -9,6 +9,8 @@ helpviewer_keywords: ["C4747"]
 
 > Calling managed 'entrypoint': Managed code may not be run under loader lock, including the DLL entrypoint and calls reached from the DLL entrypoint
 
+## Remarks
+
 The compiler found a (probable) DLL entry point compiled to MSIL.  Because of potential problems with loading a DLL whose entry point has been compiled to MSIL, you are strongly discouraged from compiling a DLL entry point function to MSIL.
 
 For more information, see [Initialization of Mixed Assemblies](../../dotnet/initialization-of-mixed-assemblies.md) and [Linker Tools Error LNK1306](../../error-messages/tool-errors/linker-tools-error-lnk1306.md).
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-3-c4723.md b/docs/error-messages/compiler-warnings/compiler-warning-level-3-c4723.md
@@ -10,6 +10,8 @@ ms.assetid: 07669d14-3fd8-4a43-94bc-b61c50e58460
 
 > potential divide by 0
 
+## Remarks
+
 The second operand in a divide operation evaluated to zero at compile time, giving undefined results.
 
 This warning is issued only when optimizations are enabled.
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-3-c4724.md b/docs/error-messages/compiler-warnings/compiler-warning-level-3-c4724.md
@@ -10,4 +10,6 @@ ms.assetid: 3be4305b-e8fe-49a9-abbf-b20dfbd71a19
 
 > potential mod by 0
 
+## Remarks
+
 The second operand in a remainder operation evaluated to zero at compile time, giving undefined results.
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-3-c4738.md b/docs/error-messages/compiler-warnings/compiler-warning-level-3-c4738.md
@@ -10,6 +10,8 @@ ms.assetid: 9094895f-7eec-46c2-83d3-249b761d585e
 
 > storing 32-bit float result in memory, possible loss of performance
 
+## Remarks
+
 C4738 warns that the result of an assignment, cast, passed argument, or other operation may need to be rounded or that the operation ran out of registers and needed to use memory (spilling). This can result in performance loss.
 
 To resolve this warning and avoid rounding, compile with [/fp:fast](../../build/reference/fp-specify-floating-point-behavior.md) or use **`double`** instead of **`float`**.
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4701.md b/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4701.md
@@ -10,6 +10,8 @@ ms.assetid: d7c76c66-1f3f-4d3c-abe4-5d94c84a5a1f
 
 > Potentially uninitialized local variable 'name' used
 
+## Remarks
+
 The local variable *name* might have been used without being assigned a value. This could lead to unpredictable results.
 
 ## Example
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4702.md b/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4702.md
@@ -10,6 +10,8 @@ ms.assetid: d8198c1e-8762-42a6-9e6b-cb568b7a1686
 
 > unreachable code
 
+## Remarks
+
 When the compiler back end detects unreachable code, it generates C4702 as a level 4 warning.
 
 To address this warning, remove the unreachable code or assure that all source code is reachable by some flow of execution.
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4706.md b/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4706.md
@@ -9,10 +9,14 @@ helpviewer_keywords: ["C4706"]
 
 > assignment used as a condition
 
+## Remarks
+
 The test value in a conditional expression is the result of an assignment.
 
 An assignment has a value (the value on the left side of the assignment) that can be used legally in another expression, including a test expression.
 
+## Example
+
 The following sample generates C4706:
 
 ```cpp
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4709.md b/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4709.md
@@ -10,6 +10,8 @@ ms.assetid: 8abfdd45-8c70-4c27-b0fb-ca0c3f0fccf9
 
 > comma operator within array index expression
 
+## Remarks
+
 When a comma occurs in an array index expression, the compiler uses the value after the last comma.
 
 ## Example
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4710.md b/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4710.md
@@ -10,6 +10,8 @@ ms.assetid: 76381ec7-3fc1-4bee-9a0a-c2c8307b92e2
 
 > '*function*' : function not inlined
 
+## Remarks
+
 The specified function was marked for inline expansion, but the compiler didn't inline the function.
 
 Inlining is done at the compiler's discretion. The **`inline`** keyword, like the deprecated (and, in C++17 and later standards, removed) **`register`** keyword, is used as a hint for the compiler. The compiler uses heuristics to determine if it should inline a particular function to speed up the code when it optimizes for speed, or if it should inline a particular function to make the code smaller when it optimizes for space. The compiler inlines only the smallest functions when compiling for space.
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4714.md b/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4714.md
@@ -10,6 +10,8 @@ ms.assetid: 22c7fd0c-899d-4e9b-95f3-725b2c49fb46
 
 > function 'function' marked as __forceinline not inlined
 
+## Remarks
+
 The given function was selected for inline expansion, but the compiler did not perform the inlining.
 
 Although **`__forceinline`** is a stronger indication to the compiler than **`__inline`**, inlining is still performed at the compiler's discretion, but no heuristics are used to determine the benefits from inlining this function.
@@ -28,6 +30,8 @@ In some cases, the compiler will not inline a particular function for mechanical
 
 - A function with a **`try`** (C++ exception handling) statement.
 
+## Example
+
 The following sample generates C4714:
 
 ```cpp
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4718.md b/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4718.md
@@ -10,4 +10,6 @@ ms.assetid: 29507f8a-b024-42c1-a3b8-f35d1f2641f3
 
 > 'function call' : recursive call has no side effects, deleting
 
+## Remarks
+
 A function contains a recursive call, but otherwise has no side effects. A call to this function is being deleted. The correctness of the program is not affected, but the behavior is. Whereas leaving the call in could result in a runtime stack overflow exception, deleting the call removes that possibility.
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4725.md b/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4725.md
@@ -10,8 +10,12 @@ ms.assetid: effa0335-71c3-4b3b-8618-da4b9b46a95d
 
 > instruction may be inaccurate on some Pentiums
 
+## Remarks
+
 Your code contains an inline assembly instruction that may not produce accurate results on some Pentium microprocessors.
 
+## Example
+
 The following sample generates C4725:
 
 ```cpp
diff --git a/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4740.md b/docs/error-messages/compiler-warnings/compiler-warning-level-4-c4740.md
@@ -10,8 +10,12 @@ ms.assetid: 85528969-966a-44b4-8a2f-971704c64477
 
 > flow in or out of inline asm code suppresses global optimization
 
+## Remarks
+
 When there is a jump in to or out of an **`asm`** block, global optimizations are disabled for that function.
 
+## Example
+
 The following sample generates C4740:
 
 ```cpp
