Merge pull request #5163 from MicrosoftDocs/main

1/22/2024 AM Publish

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/cpp/welcome-back-to-cpp-modern-cpp.md

@@ -3,7 +3,6 @@ title: "Welcome back to C++ - Modern C++"
 description: "Describes the new programming idioms in Modern C++ and their rationale."
 ms.date: 06/02/2022
 ms.topic: "conceptual"
-ms.assetid: 1cb1b849-ed9c-4721-a972-fd8f3dab42e2
 ---
 # Welcome back to C++ - Modern C++
 
@@ -64,10 +63,7 @@ apple_color["Granny Smith"] = "Green";
 
 When performance optimization is needed, consider using:
 
-- The [`array`](../standard-library/array-class-stl.md) type when embedding is important, for example, as a class member.
-
 - Unordered associative containers such as [`unordered_map`](../standard-library/unordered-map-class.md). These have lower per-element overhead and constant-time lookup, but they can be harder to use correctly and efficiently.
-
 - Sorted `vector`. For more information, see [Algorithms](../standard-library/algorithms.md).
 
 Don't use C-style arrays. For older APIs that need direct access to the data, use accessor methods such as `f(vec.data(), vec.size());` instead. For more information about containers, see [C++ Standard Library Containers](../standard-library/stl-containers.md).
@@ -79,11 +75,8 @@ Before you assume that you need to write a custom algorithm for your program, fi
 Here are some important examples:
 
 - `for_each`, the default traversal algorithm (along with range-based `for` loops).
-
 - `transform`, for not-in-place modification of container elements
-
 - `find_if`, the default search algorithm.
-
 - `sort`, `lower_bound`, and the other default sorting and searching algorithms.
 
 To write a comparator, use strict **`<`** and use *named lambdas* when you can.

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/error-messages/compiler-warnings/c4834.md

@@ -1,7 +1,7 @@
 ---
 description: "Learn about the cause and fixes for Compiler warning (level 1) C4834."
 title: "Compiler warning (Level 1) C4834"
-ms.date: 07/26/2021
+ms.date: 01/18/2024
 f1_keywords: ["C4834"]
 helpviewer_keywords: ["C4834"]
 ---
@@ -11,7 +11,7 @@ helpviewer_keywords: ["C4834"]
 
 ## Remarks
 
-Starting in the C++17 Standard, the `[[nodiscard]]` attribute specifies that a function's return value isn't intended to be discarded. If a caller discards the return value, the compiler generates warning C4834.
+Starting in the C++17 Standard, the `[[nodiscard]]` attribute specifies that a function's return value isn't intended to be discarded. If a caller discards the return value, the compiler generates warning C4834. Although this attribute was introduced in C++17, the compiler respects this attribute and generates warnings related to it when using `/std:c++14` and later.
 
 To resolve this warning, consider why your code doesn't use the return value. Your use of the function may not match its intent. You can circumvent the warning by assigning the value to **`std::ignore`** or by casting it to **`void`** if discarding the value is intentional.  
 Assignment to **`std::ignore`** is preferred over casting to **`void`** in C++11 and higher, as it makes your intent clearer and will not trigger [Warning C26457](../../code-quality/c26457.md) if enabled in your code analysis settings.