Merge pull request #5156 from MicrosoftDocs/FromPublicMasterBranch

Confirm merge from FromPublicMasterBranch to main to sync with https://github.com/MicrosoftDocs/cpp-docs (branch main)

Author: PhilKang0704

docs/c-runtime-library/reference/vsnprintf-vsnprintf-vsnprintf-l-vsnwprintf-vsnwprintf-l.md

@@ -125,7 +125,7 @@ See [Behavior summary](#behavior-summary) for details.
 
 Each of these functions takes a pointer to an argument list, then formats the data, and writes up to *`count`* characters to the memory pointed to by *`buffer`*. The **`vsnprintf`** function always writes a null terminator, even if it truncates the output. When you use **`_vsnprintf`** and **`_vsnwprintf`**, the buffer is null-terminated only if there's room at the end (that is, if the number of characters to write is less than *`count`*).
 
-Beginning with the UCRT in Visual Studio 2015 and Windows 10, **`vsnprintf`** is no longer identical to **`_vsnprintf`**. The **`vsnprintf`** function conforms to the C99 standard; **`_vnsprintf`** is kept for backward compatibility with older code. The difference is that if you run out of buffer, `vsnprintf` null-terminates the end of the buffer and returns the number of characters that would have been required, while `_vsnprintf` doesn't null-terminate the buffer and returns -1. Also, `_vsnprintf()` includes one more character in the output because it doesn't null-terminate the buffer.
+Beginning with the UCRT in Visual Studio 2015 and Windows 10, **`vsnprintf`** is no longer identical to **`_vsnprintf`**. The **`vsnprintf`** function conforms to the C99 standard; **`_vsnprintf`** is kept for backward compatibility with older code. The difference is that if you run out of buffer, `vsnprintf` null-terminates the end of the buffer and returns the number of characters that would have been required, while `_vsnprintf` doesn't null-terminate the buffer and returns -1. Also, `_vsnprintf()` includes one more character in the output because it doesn't null-terminate the buffer.
 
 > [!IMPORTANT]
 > To prevent certain kinds of security risks, ensure that *`format`* isn't a user-defined string. For more information, see [Avoiding buffer overruns](/windows/win32/SecBP/avoiding-buffer-overruns).

docs/cpp/inline-functions-cpp.md

@@ -20,35 +20,38 @@ A function defined in the body of a class declaration is implicitly an inline fu
 In the following class declaration, the `Account` constructor is an inline function because it is defined in the body of the class declaration. The member functions `GetBalance`, `Deposit`, and `Withdraw` are specified `inline` in their definitions. The `inline` keyword is optional in the function declarations in the class declaration.
 
 ```cpp
-// Inline_Member_Functions.cpp
+// account.h
 class Account
 {
 public:
-    Account(double initial_balance) { balance = initial_balance; }
-    double GetBalance();
-    double Deposit( double Amount );
-    double Withdraw( double Amount );
+    Account(double initial_balance)
+    {
+        balance = initial_balance;
+    }
+
+    double GetBalance() const;
+    double Deposit(double amount);
+    double Withdraw(double amount);
+
 private:
     double balance;
 };
 
-inline double Account::GetBalance()
+inline double Account::GetBalance() const
 {
     return balance;
 }
 
-inline double Account::Deposit( double Amount )
-{
-    return ( balance += Amount );
-}
-
-inline double Account::Withdraw( double Amount )
+inline double Account::Deposit(double amount)
 {
-    return ( balance -= Amount );
+    balance += amount;
+    return balance;
 }
 
-int main()
+inline double Account::Withdraw(double amount)
 {
+    balance -= amount;
+    return balance;
 }
 ```
 
@@ -90,10 +93,9 @@ Use the [`/Ob`](../build/reference/ob-inline-function-expansion.md) compiler opt
 ```cpp
 // inline_keyword1.cpp
 // compile with: /c
-inline int max( int a , int b ) {
-   if( a > b )
-      return a;
-   return b;
+inline int max(int a, int b)
+{
+    return a < b ? b : a;
 }
 ```
 
@@ -105,13 +107,14 @@ A class's member functions can be declared inline, either by using the **`inline
 // inline_keyword2.cpp
 // compile with: /EHsc /c
 #include <iostream>
-using namespace std;
 
-class MyClass {
+class MyClass
+{
 public:
-   void print() { cout << i << ' '; }   // Implicitly inline
+    void print() { std::cout << i; }   // Implicitly inline
+
 private:
-   int i;
+    int i;
 };
 ```
 
@@ -152,13 +155,15 @@ A `Point` class can be defined as follows:
 
 ```cpp
 // when_to_use_inline_functions.cpp
+// compile with: /c
 class Point
 {
 public:
-    // Define "accessor" functions as
-    //  reference types.
+    // Define "accessor" functions
+    // as reference types.
     unsigned& x();
     unsigned& y();
+
 private:
     unsigned _x;
     unsigned _y;
@@ -168,13 +173,11 @@ inline unsigned& Point::x()
 {
     return _x;
 }
+
 inline unsigned& Point::y()
 {
     return _y;
 }
-int main()
-{
-}
 ```
 
 Assuming coordinate manipulation is a relatively common operation in a client of such a class, specifying the two accessor functions (`x` and `y` in the preceding example) as **`inline`** typically saves the overhead on:
@@ -193,7 +196,9 @@ A macro has some things in common with an `inline` function. But there are impor
 ```cpp
 #include <iostream>
 
-#define mult(a, b) a * b
+#define mult1(a, b) a * b
+#define mult2(a, b) (a) * (b)
+#define mult3(a, b) ((a) * (b))
 
 inline int multiply(int a, int b)
 {
@@ -202,40 +207,67 @@ inline int multiply(int a, int b)
 
 int main()
 {
-    std::cout << mult(5 + 5, 5 + 5) << std::endl; // outputs 35
-    std::cout << multiply(5 + 5, 5 + 5) << std::endl; // outputs 100
+    std::cout << (48 / mult1(2 + 2, 3 + 3)) << std::endl; // outputs 33
+    std::cout << (48 / mult2(2 + 2, 3 + 3)) << std::endl; // outputs 72
+    std::cout << (48 / mult3(2 + 2, 3 + 3)) << std::endl; // outputs 2
+    std::cout << (48 / multiply(2 + 2, 3 + 3)) << std::endl; // outputs 2
 
-    std::cout << mult(2, 2.2) << std::endl>>; // no warning
+    std::cout << mult3(2, 2.2) << std::endl; // no warning
     std::cout << multiply(2, 2.2); // Warning C4244	'argument': conversion from 'double' to 'int', possible loss of data
 }
 ```
 
 ```Output
-35
-100
+33
+72
+2
+2
 4.4
 4
 ```
 
 Here are some of the differences between the macro and the inline function:
 
 - Macros are always expanded inline. However, an inline function is only inlined when the compiler determines it is the optimal thing to do.
-- The macro may result in unexpected behavior. For example, the macro `mult(5+5,5+5)` expands to `5 + 5 * 5 + 5` resulting in 35, whereas the function evaluates `10 * 10`. You could address that by defining the macro as #define `mult(a, b) ((a)*(b))`.
+- The macro may result in unexpected behavior, which can lead to subtle bugs. For example, the expression `mult1(2 + 2, 3 + 3)` expands to `2 + 2 * 3 + 3` which evaluates to 11, but the expected result is 24. A seemingly valid fix is to add parentheses around both arguments of the function macro, resulting in `#define mult2(a, b) (a) * (b)`, which will solve the issue at hand but can still cause surprising behavior when part of a larger expression. That was demonstrated in the preceding example, and the problem could be addressed by defining the macro as such `#define mult3(a, b) ((a) * (b))`.
 - An inline function is subject to semantic processing by the compiler, whereas the preprocessor expands macros without that same benefit. Macros aren't type-safe, whereas functions are.
 - Expressions passed as arguments to inline functions are evaluated once. In some cases, expressions passed as arguments to macros can be evaluated more than once. For example, consider the following:
 
 ```cpp
+#include <iostream>
+
 #define sqr(a) ((a) * (a))
 
+int increment(int& number)
+{
+    return number++;
+}
+
+inline int square(int a)
+{
+    return a * a;
+}
+
 int main()
 {
     int c = 5;
-    std::cout << sqr(c++) << std::endl; // outputs 25
-    std::cout << c << std::endl; // outputs 7!
+    std::cout << sqr(increment(c)) << std::endl; // outputs 30
+    std::cout << c << std::endl; // outputs 7
+
+    c = 5;
+    std::cout << square(increment(c)) << std::endl; // outputs 25
+    std::cout << c; // outputs 6
 }
 ```
 
-In this example, the expression `c++` is evaluated twice; once for each occurrence of `a` in the macro expansion. Instead, if `sqr` were an inline function, the expression `c++` would be evaluated only once.
+```Output
+30
+7
+25
+6
+```
+
+In this example, the function `increment` is called twice as the expression `sqr(increment(c))` expands to `((increment(c)) * (increment(c)))`. This caused the second invocation of `increment` to return 6, hence the expression evaluates to 30. Any expression that contains side effects may affect the result when used in a macro, examine the fully expanded macro to check if the behavior is intended. Instead, if the inline function `square` was used, the function `increment` would only be called once and the correct result of 25 will be obtained.
 
 ## See also
 

docs/error-messages/compiler-errors-1/compiler-error-c2385.md

@@ -1,66 +1,63 @@
 ---
 description: "Learn more about: Compiler Error C2385"
 title: "Compiler Error C2385"
-ms.date: "11/04/2016"
+ms.date: "1/19/2024"
 f1_keywords: ["C2385"]
 helpviewer_keywords: ["C2385"]
-ms.assetid: 6d3dd1f2-e56d-49d7-865c-6a9acdb17417
 ---
 # Compiler Error C2385
 
-ambiguous access of 'member'
+> ambiguous access of 'member'
 
-The member can derive from more than one object (it is inherited from more than one object).  To resolve this error,
+A member is inherited from more than one base type, making unqualified access to that member ambiguous. To resolve this error:
 
-- Make the member unambiguous by providing a cast.
-
-- Rename the ambiguous members in the base classes.
+- Explicitly qualify access to the member.
+- Cast the object to the base class containing the member before accessing the member.
+- Rename the ambiguous member in the base class.
+- Bring the member into scope.
 
 ## Example
 
-The following sample generates C2385.
+The following sample generates C2385:
 
 ```cpp
 // C2385.cpp
-// C2385 expected
-#include <stdio.h>
-
 struct A
 {
-    void x(int i)
-    {
-        printf_s("\nIn A::x");
-    }
+    void func1(int i) {}
+    void func2() {}
 };
 
 struct B
 {
-    void x(char c)
-    {
-        printf_s("\nIn B::x");
-    }
+    void func1(char c) {}
+    void func2() {}
 };
 
-// Delete the following line to resolve.
-struct C : A, B {}
-
-// Uncomment the following 4 lines to resolve.
-// struct C : A, B
-// {
-//     using B::x;
-//     using A::x;
-// };
+struct C : A, B
+{
+    // Uncomment the following lines to resolve the first 2 errors
+    // The error below for the call to c.func2() will remain
+    // using A::func1;
+    // using B::func1;
+};
 
 int main()
 {
-    C aC;
-    aC.x(100);
-    aC.x('c');
-}
+    C c;
 
-struct C : A, B
-{
-    using B::x;
-    using A::x;
-};
+    c.func1(123); // C2385
+    c.func1('a'); // C2385
+    c.func2(); // C2385
+
+    c.A::func2(); // OK because explicitly qualified
+    c.B::func2(); // OK because explicitly qualified
+    static_cast<A>(c).func2(); // OK because of the cast
+    static_cast<B>(c).func2(); // OK because of the cast
+}
 ```
+
+You can resolve the ambiguous calls to `func1` by bringing both overloads into scope. However, this doesn't work for `func2` because `A::func2` and `B::func2` don't take arguments, so calling them can't be differentiated by their parameters. You can resolve the issue by:
+- Introduce the one you want to use into scope
+- Explicitly qualify the call with the base type
+- Cast the object before calling the function.

docs/intrinsics/rdtsc.md

@@ -62,4 +62,5 @@ int main()
 
 ## See also
 
+[__rdtscp](../intrinsics/rdtscp.md)\
 [Compiler intrinsics](../intrinsics/compiler-intrinsics.md)

docs/intrinsics/rdtscp.md

@@ -10,7 +10,7 @@ ms.assetid: f17d9a9c-88bb-44e0-b69d-d516bc1c93ee
 
 **Microsoft Specific**
 
-Generates the `rdtscp` instruction, writes `TSC_AUX[31:0`] to memory, and returns the 64-bit Time Stamp Counter (`TSC)` result.
+Generates the `rdtscp` instruction, writes `TSC_AUX[31:0]` to memory, and returns the 64-bit Time Stamp Counter (TSC) result.
 
 ## Syntax
 
@@ -39,7 +39,7 @@ A 64-bit unsigned integer tick count.
 
 ## Remarks
 
-The `__rdtscp` intrinsic generates the `rdtscp` instruction. To determine hardware support for this instruction, call the `__cpuid` intrinsic with `InfoType=0x80000001` and check bit 27 of `CPUInfo[3] (EDX)`. This bit is 1 if the instruction is supported, and 0 otherwise.  If you run code that uses the intrinsic on hardware that doesn't support the `rdtscp` instruction, the results are unpredictable.
+The `__rdtscp` intrinsic generates the `rdtscp` instruction. To determine hardware support for this instruction, call the `__cpuid` intrinsic with `InfoType=0x80000001` and check bit 27 of `CPUInfo[3] (EDX)`. This bit is 1 if the instruction is supported, and 0 otherwise. If you run code that uses the intrinsic on hardware that doesn't support the `rdtscp` instruction, the results are unpredictable.
 
 This instruction waits until all previous instructions have executed and all previous loads are globally visible. However, it isn't a serializing instruction. For more information, see the Intel and AMD manuals.