Merge pull request #2889 from corob-msft/cr-zh-cn-126

I18n fixes per cpp-docs.zh-cn#126

Author: Court72

docs/cpp/welcome-back-to-cpp-modern-cpp.md

@@ -1,7 +1,7 @@
 ---
 title: "Welcome back to C++ - Modern C++"
 description: "Describes the new programming idioms in Modern C++ and their rationale."
-ms.date: "01/10/2020"
+ms.date: "05/17/2020"
 ms.topic: "conceptual"
 ms.assetid: 1cb1b849-ed9c-4721-a972-fd8f3dab42e2
 ---
@@ -11,13 +11,13 @@ Since its creation, C++ has become one of the most widely used programming langu
 
 One of the original requirements for C++ was backward compatibility with the C language. As a result, C++ has always permitted C-style programming, with raw pointers, arrays, null-terminated character strings, and other features. They may enable great performance, but can also spawn bugs and complexity. The evolution of C++ has emphasized features that greatly reduce the need to use C-style idioms. The old C-programming facilities are there when you need them, but with modern C++ code you should need them less and less. Modern C++ code is simpler, safer, more elegant, and still as fast as ever.
 
-The following sections provide an overview of the main features of modern C++. Unless noted otherwise, the features listed here are available in C++11 and later. In the Microsoft C++ compiler, you can set the [/std](../build/reference/std-specify-language-standard-version.md) compiler option to specify which version of the standard to use for your project.
+The following sections provide an overview of the main features of modern C++. Unless noted otherwise, the features listed here are available in C++11 and later. In the Microsoft C++ compiler, you can set the [`/std`](../build/reference/std-specify-language-standard-version.md) compiler option to specify which version of the standard to use for your project.
 
 ## Resources and smart pointers
 
-One of the major classes of bugs in C-style programming is the *memory leak*. Leaks are often caused by a failure to call **delete** for memory that was allocated with **new**. Modern C++ emphasizes the principle of *resource acquisition is initialization* (RAII). The idea is simple. Resources (heap memory, file handles, sockets, and so on) should be *owned* by an object. That object creates, or receives, the newly allocated resource in its constructor, and deletes it in its destructor. The principle of RAII guarantees that all resources get properly returned to the operating system when the owning object goes out of scope.
+One of the major classes of bugs in C-style programming is the *memory leak*. Leaks are often caused by a failure to call **`delete`** for memory that was allocated with **`new`**. Modern C++ emphasizes the principle of *resource acquisition is initialization* (RAII). The idea is simple. Resources (heap memory, file handles, sockets, and so on) should be *owned* by an object. That object creates, or receives, the newly allocated resource in its constructor, and deletes it in its destructor. The principle of RAII guarantees that all resources get properly returned to the operating system when the owning object goes out of scope.
 
-To support easy adoption of RAII principles, the C++ Standard Library provides three smart pointer types: [std::unique_ptr](../standard-library/unique-ptr-class.md), [std::shared_ptr](../standard-library/shared-ptr-class.md), and [std::weak_ptr](../standard-library/weak-ptr-class.md). A smart pointer handles the allocation and deletion of the memory it owns. The following example shows a class with an array member that is allocated on the heap in the call to `make_unique()`. The calls to **new** and **delete** are encapsulated by the `unique_ptr` class. When a `widget` object goes out of scope, the unique_ptr destructor will be invoked and it will release the memory that was allocated for the array.  
+To support easy adoption of RAII principles, the C++ Standard Library provides three smart pointer types: [`std::unique_ptr`](../standard-library/unique-ptr-class.md), [`std::shared_ptr`](../standard-library/shared-ptr-class.md), and [`std::weak_ptr`](../standard-library/weak-ptr-class.md). A smart pointer handles the allocation and deletion of the memory it owns. The following example shows a class with an array member that is allocated on the heap in the call to `make_unique()`. The calls to **`new`** and **`delete`** are encapsulated by the `unique_ptr` class. When a `widget` object goes out of scope, the unique_ptr destructor will be invoked and it will release the memory that was allocated for the array.  
 
 ```cpp
 #include <memory>
@@ -42,20 +42,20 @@ void functionUsingWidget() {
 
 Whenever possible, use a smart pointer when allocating heap memory. If you must use the new and delete operators explicitly, follow the principle of RAII. For more information, see [Object lifetime and resource management (RAII)](object-lifetime-and-resource-management-modern-cpp.md).
 
-## std::string and std::string_view
+## `std::string` and `std::string_view`
 
-C-style strings are another major source of bugs. By using [std::string and std::wstring](../standard-library/basic-string-class.md), you can eliminate virtually all the errors associated with C-style strings. You also gain the benefit of member functions for searching, appending, prepending, and so on. Both are highly optimized for speed. When passing a string to a function that requires only read-only access, in C++17 you can use [std::string_view](../standard-library/basic-string-view-class.md) for even greater performance benefit.
+C-style strings are another major source of bugs. By using [`std::string` and `std::wstring`](../standard-library/basic-string-class.md), you can eliminate virtually all the errors associated with C-style strings. You also gain the benefit of member functions for searching, appending, prepending, and so on. Both are highly optimized for speed. When passing a string to a function that requires only read-only access, in C++17 you can use [`std::string_view`](../standard-library/basic-string-view-class.md) for even greater performance benefit.
 
-## std::vector and other Standard Library containers
+## `std::vector` and other Standard Library containers
 
-The Standard Library containers all follow the principle of RAII. They provide iterators for safe traversal of elements. And, they're highly optimized for performance and have been thoroughly tested for correctness. By using these containers, you eliminate the potential for bugs or inefficiencies that might be introduced in custom data structures. Instead of raw arrays, use [vector](../standard-library/vector-class.md) as a sequential container in C++.
+The standard library containers all follow the principle of RAII. They provide iterators for safe traversal of elements. And, they're highly optimized for performance and have been thoroughly tested for correctness. By using these containers, you eliminate the potential for bugs or inefficiencies that might be introduced in custom data structures. Instead of raw arrays, use [`vector`](../standard-library/vector-class.md) as a sequential container in C++.
 
 ```cpp
 vector<string> apples;
 apples.push_back("Granny Smith");
 ```
 
-Use [map](../standard-library/map-class.md) (not `unordered_map`) as the default associative container. Use [set](../standard-library/set-class.md), [multimap](../standard-library/multimap-class.md), and [multiset](../standard-library/multiset-class.md) for degenerate and multi cases.
+Use [`map`](../standard-library/map-class.md) (not `unordered_map`) as the default associative container. Use [`set`](../standard-library/set-class.md), [`multimap`](../standard-library/multimap-class.md), and [`multiset`](../standard-library/multiset-class.md) for degenerate and multi cases.
 
 ```cpp
 map<string, string> apple_color;
@@ -65,9 +65,9 @@ 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.
+- 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.
+- 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](../cpp/algorithms-modern-cpp.md).
 
@@ -79,15 +79,15 @@ 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).
+- `for_each`, the default traversal algorithm (along with range-based `for` loops).
 
-- **transform**, for not-in-place modification of container elements
+- `transform`, for not-in-place modification of container elements
 
-- **find_if**, the default search algorithm.
+- `find_if`, the default search algorithm.
 
-- **sort**, **lower_bound**, and the other default sorting and searching algorithms.
+- `sort`, `lower_bound`, and the other default sorting and searching algorithms.
 
-To write a comparator, use strict **<** and use *named lambdas* when you can.
+To write a comparator, use strict **`<`** and use *named lambdas* when you can.
 
 ```cpp
 auto comp = [](const widget& w1, const widget& w2)
@@ -98,18 +98,18 @@ sort( v.begin(), v.end(), comp );
 auto i = lower_bound( v.begin(), v.end(), comp );
 ```
 
-## auto instead of explicit type names
+## `auto` instead of explicit type names
 
-C++11 introduced the [auto](auto-cpp.md) keyword for use in variable, function, and template declarations. **auto** tells the compiler to deduce the type of the object so that you don't have to type it explicitly. **auto** is especially useful when the deduced type is a nested template:
+C++11 introduced the [`auto`](auto-cpp.md) keyword for use in variable, function, and template declarations. **`auto`** tells the compiler to deduce the type of the object so that you don't have to type it explicitly. **`auto`** is especially useful when the deduced type is a nested template:
 
 ```cpp
 map<int,list<string>>::iterator i = m.begin(); // C-style
 auto i = m.begin(); // modern C++
 ```
 
-## Range-based for loops
+## Range-based `for` loops
 
-C-style iteration over arrays and containers is prone to indexing errors and is also tedious to type. To eliminate these errors, and make your code more readable, use range-based for loops with both Standard Library containers and raw arrays. For more information, see [Range-based for statement](../cpp/range-based-for-statement-cpp.md).
+C-style iteration over arrays and containers is prone to indexing errors and is also tedious to type. To eliminate these errors, and make your code more readable, use range-based `for` loops with both Standard Library containers and raw arrays. For more information, see [Range-based `for` statement](../cpp/range-based-for-statement-cpp.md).
 
 ```cpp
 #include <iostream>
@@ -133,9 +133,9 @@ int main()
 }
 ```
 
-## constexpr expressions instead of macros
+## `constexpr` expressions instead of macros
 
-Macros in C and C++ are tokens that are processed by the preprocessor before compilation. Each instance of a macro token is replaced with its defined value or expression before the file is compiled. Macros are commonly used in C-style programming to define compile-time constant values. However, macros are error-prone and difficult to debug. In modern C++, you should prefer [constexpr](constexpr-cpp.md) variables for compile-time constants:
+Macros in C and C++ are tokens that are processed by the preprocessor before compilation. Each instance of a macro token is replaced with its defined value or expression before the file is compiled. Macros are commonly used in C-style programming to define compile-time constant values. However, macros are error-prone and difficult to debug. In modern C++, you should prefer [`constexpr`](constexpr-cpp.md) variables for compile-time constants:
 
 ```cpp
 #define SIZE 10 // C-style
@@ -181,11 +181,11 @@ For more information, see [Brace initialization](initializing-classes-and-struct
 
 ## Move semantics
 
-Modern C++ provides *move semantics*, which make it possible to eliminate unnecessary memory copies. In earlier versions of the language, copies were unavoidable in certain situations. A *move* operation transfers ownership of a resource from one object to the next without making a copy. When implementing a class that owns a resource (such as heap memory, file handles, and so on), you can define a *move constructor* and *move assignment operator* for it. The compiler will choose these special members during overload resolution in situations where a copy isn't needed. The Standard Library container types invoke the move constructor on objects if one is defined. For more information, see [Move Constructors and Move Assignment Operators (C++)](move-constructors-and-move-assignment-operators-cpp.md).
+Modern C++ provides *move semantics*, which make it possible to eliminate unnecessary memory copies. In earlier versions of the language, copies were unavoidable in certain situations. A *move* operation transfers ownership of a resource from one object to the next without making a copy. Some classes own resources such as heap memory, file handles, and so on. When you implement a resource-owning class, you can define a *move constructor* and *move assignment operator* for it. The compiler chooses these special members during overload resolution in situations where a copy isn't needed. The Standard Library container types invoke the move constructor on objects if one is defined. For more information, see [Move Constructors and Move Assignment Operators (C++)](move-constructors-and-move-assignment-operators-cpp.md).
 
 ## Lambda expressions
 
-In C-style programming, a function can be passed to another function by using a *function pointer*. Function pointers are inconvenient to maintain and understand. The function they refer to may be defined elsewhere in the source code, far away from the point at which it's invoked. Also, they're not type-safe. Modern C++ provides *function objects*, classes that override the [()](function-call-operator-parens.md) operator, which enables them to be called like a function. The most convenient way to create function objects is with inline [lambda expressions](../cpp/lambda-expressions-in-cpp.md). The following example shows how to use a lambda expression to pass a function object, that the `for_each` function will invoke on each element in the vector:
+In C-style programming, a function can be passed to another function by using a *function pointer*. Function pointers are inconvenient to maintain and understand. The function they refer to may be defined elsewhere in the source code, far away from the point at which it's invoked. Also, they're not type-safe. Modern C++ provides *function objects*, classes that override the [`operator()`](function-call-operator-parens.md) operator, which enables them to be called like a function. The most convenient way to create function objects is with inline [lambda expressions](../cpp/lambda-expressions-in-cpp.md). The following example shows how to use a lambda expression to pass a function object, that the `for_each` function will invoke on each element in the vector:
 
 ```cpp
     std::vector<int> v {1,2,3,4,5};
@@ -200,13 +200,13 @@ The lambda expression `[=](int i) { return i > x && i < y; }` can be read as "fu
 
 Modern C++ emphasizes exceptions rather than error codes as the best way to report and handle error conditions. For more information, see [Modern C++ best practices for exceptions and error handling](errors-and-exception-handling-modern-cpp.md).
 
-## std::atomic
+## `std::atomic`
 
-Use the C++ Standard Library [std::atomic](../standard-library/atomic-structure.md) struct and related types for inter-thread communication mechanisms.
+Use the C++ Standard Library [`std::atomic`](../standard-library/atomic-structure.md) struct and related types for inter-thread communication mechanisms.
 
-## std::variant (C++17)
+## `std::variant` (C++17)
 
-Unions are commonly used in C-style programming to conserve memory by enabling members of different types to occupy the same memory location. However, unions aren't type-safe and are prone to programming errors. C++17 introduces the [std::variant](../standard-library/variant-class.md) class as a more robust and safe alternative to unions. The [std::visit](../standard-library/variant-functions.md#visit) function can be used to access the members of a `variant` type in a type-safe manner.
+Unions are commonly used in C-style programming to conserve memory by enabling members of different types to occupy the same memory location. However, unions aren't type-safe and are prone to programming errors. C++17 introduces the [`std::variant`](../standard-library/variant-class.md) class as a more robust and safe alternative to unions. The [`std::visit`](../standard-library/variant-functions.md#visit) function can be used to access the members of a `variant` type in a type-safe manner.
 
 ## See also