Merge pull request #4328 from corob-msft/docs/corob/cpp-docs-3952

Address cpp-docs 3952

Author: v-ccolin

docs/cpp/object-lifetime-and-resource-management-modern-cpp.md

@@ -1,13 +1,13 @@
 ---
 title: "Object lifetime and resource management (RAII)"
 description: "Follow the principle of RAII in modern C++ to avoid resource leaks."
-ms.date: "11/19/2019"
+ms.date: 06/02/2022
 ms.topic: "conceptual"
 ms.assetid: 8aa0e1a1-e04d-46b1-acca-1d548490700f
 ---
 # Object lifetime and resource management (RAII)
 
-Unlike managed languages, C++ doesn't have automatic *garbage collection*. That's an internal process that releases heap memory and other resources as a program runs. A C++ program is responsible for returning all acquired resources to the operating system. Failure to release an unused resource is called a *leak*. Leaked resources are unavailable to other programs until the process exits. Memory leaks in particular are a common cause of bugs in C-style programming.
+Unlike managed languages, C++ doesn't have automatic *garbage collection*, an internal process that releases heap memory and other resources as a program runs. A C++ program is responsible for returning all acquired resources to the operating system. Failure to release an unused resource is called a *leak*. Leaked resources are unavailable to other programs until the process exits. Memory leaks in particular are a common cause of bugs in C-style programming.
 
 Modern C++ avoids using heap memory as much as possible by declaring objects on the stack. When a resource is too large for the stack, then it should be *owned* by an object. As the object gets initialized, it acquires the resource it owns. The object is then responsible for releasing the resource in its destructor. The owning object itself is declared on the stack. The principle that *objects own resources* is also known as "resource acquisition is initialization," or RAII.
 
@@ -48,7 +48,7 @@ public:
 };
 
 void functionUsingWidget() {
-    widget w(1000000);   // lifetime automatically tied to enclosing scope
+    widget w(1000000);  // lifetime automatically tied to enclosing scope
                         // constructs w, including the w.data member
     w.do_something();
 
@@ -63,20 +63,19 @@ Since C++11, there's a better way to write the previous example: by using a smar
 class widget
 {
 private:
-    std::unique_ptr<int> data;
+    std::unique_ptr<int[]> data;
 public:
-    widget(const int size) { data = std::make_unique<int>(size); }
+    widget(const int size) { data = std::make_unique<int[]>(size); }
     void do_something() {}
 };
 
 void functionUsingWidget() {
-    widget w(1000000);   // lifetime automatically tied to enclosing scope
-                // constructs w, including the w.data gadget member
+    widget w(1000000);  // lifetime automatically tied to enclosing scope
+                        // constructs w, including the w.data gadget member
     // ...
     w.do_something();
     // ...
 } // automatic destruction and deallocation for w and w.data
-
 ```
 
 By using smart pointers for memory allocation, you may eliminate the potential for memory leaks. This model works for other resources, such as file handles or sockets. You can manage your own resources in a similar way in your classes. For more information, see [Smart pointers](smart-pointers-modern-cpp.md).
@@ -85,6 +84,6 @@ The design of C++ ensures objects are destroyed when they go out of scope. That
 
 ## See also
 
-[Welcome back to C++](../cpp/welcome-back-to-cpp-modern-cpp.md)<br/>
-[C++ Language Reference](../cpp/cpp-language-reference.md)<br/>
+[Welcome back to C++](../cpp/welcome-back-to-cpp-modern-cpp.md)\
+[C++ language reference](../cpp/cpp-language-reference.md)\
 [C++ Standard Library](../standard-library/cpp-standard-library-reference.md)

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: 02/07/2022
+ms.date: 06/02/2022
 ms.topic: "conceptual"
 ms.assetid: 1cb1b849-ed9c-4721-a972-fd8f3dab42e2
 ---
@@ -24,15 +24,15 @@ To support easy adoption of RAII principles, the C++ Standard Library provides t
 class widget
 {
 private:
-    std::unique_ptr<int> data;
+    std::unique_ptr<int[]> data;
 public:
-    widget(const int size) { data = std::make_unique<int>(size); }
+    widget(const int size) { data = std::make_unique<int[]>(size); }
     void do_something() {}
 };
 
 void functionUsingWidget() {
-    widget w(1000000);   // lifetime automatically tied to enclosing scope
-                // constructs w, including the w.data gadget member
+    widget w(1000000);  // lifetime automatically tied to enclosing scope
+                        // constructs w, including the w.data gadget member
     // ...
     w.do_something();
     // ...