@@ -0,0 +1,29 @@
+void use_shared_ptr_by_value(shared_ptr<int> sp);
+
+void use_shared_ptr_by_reference(shared_ptr<int>& sp);
+void use_shared_ptr_by_const_reference(const shared_ptr<int>& sp);
+
+void use_raw_pointer(int* p);
+void use_reference(int& r);
+
+void test() {
+    auto sp = make_shared<int>(5);
+
+    // Pass the shared_ptr by value.
+    // This invokes the copy constructor, increments the reference count, and makes the callee an owner.
+    use_shared_ptr_by_value(sp);
+
+    // Pass the shared_ptr by reference or const reference.
+    // In this case, the reference count isn't incremented.
+    use_shared_ptr_by_reference(sp);
+    use_shared_ptr_by_const_reference(sp);
+
+    // Pass the underlying pointer or a reference to the underlying object.
+    use_raw_pointer(sp.get());
+    use_reference(*sp);
+
+    // Pass the shared_ptr by value.
+    // This invokes the move constructor, which doesn't increment the reference count
+    // but in fact transfers ownership to the callee.
+    use_shared_ptr_by_value(move(sp));
+}
@@ -2,7 +2,7 @@
 description: "Learn more about: How to: Create and Use shared_ptr instances"
 title: "How to: Create and use shared_ptr instances"
 ms.custom: "how-to"
-ms.date: "11/19/2019"
+ms.date: "05/26/2023"
 ms.topic: "conceptual"
 ms.assetid: 7d6ebb73-fa0d-4b0b-a528-bf05de96518e
 ---
@@ -81,13 +81,13 @@ The following example shows how to declare and initialize `shared_ptr` instances
 
 `shared_ptr` is also helpful in C++ Standard Library containers when you're using algorithms that copy elements. You can wrap elements in a `shared_ptr`, and then copy it into other containers with the understanding that the underlying memory is valid as long as you need it, and no longer. The following example shows how to use the `remove_copy_if` algorithm on `shared_ptr` instances in a vector.
 
-[!code-cpp[stl_smart_pointers#4](codesnippet/CPP/how-to-create-and-use-shared-ptr-instances_3.cpp)]
+[!code-cpp[stl_smart_pointers#3](codesnippet/CPP/how-to-create-and-use-shared-ptr-instances_3.cpp)]
 
 ## Example 4
 
 You can use `dynamic_pointer_cast`, `static_pointer_cast`, and `const_pointer_cast` to cast a `shared_ptr`. These functions resemble the **`dynamic_cast`**, **`static_cast`**, and **`const_cast`** operators. The following example shows how to test the derived type of each element in a vector of `shared_ptr` of base classes, and then copy the elements and display information about them.
 
-[!code-cpp[stl_smart_pointers#5](codesnippet/CPP/how-to-create-and-use-shared-ptr-instances_4.cpp)]
+[!code-cpp[stl_smart_pointers#4](codesnippet/CPP/how-to-create-and-use-shared-ptr-instances_4.cpp)]
 
 ## Example 5
 
@@ -105,11 +105,13 @@ You can pass a `shared_ptr` to another function in the following ways:
 
 - Sometimes, for example in a `std::vector<shared_ptr<T>>`, you may have to pass each `shared_ptr` to a lambda expression body or named function object. If the lambda or function doesn't store the pointer, then pass the `shared_ptr` by reference to avoid invoking the copy constructor for each element.
 
+[!code-cpp[stl_smart_pointers#5](codesnippet/CPP/how-to-create-and-use-shared-ptr-instances_5.cpp)]
+
 ## Example 6
 
 The following example shows how `shared_ptr` overloads various comparison operators to enable pointer comparisons on the memory that is owned by the `shared_ptr` instances.
 
-[!code-cpp[stl_smart_pointers#3](codesnippet/CPP/how-to-create-and-use-shared-ptr-instances_6.cpp)]
+[!code-cpp[stl_smart_pointers#6](codesnippet/CPP/how-to-create-and-use-shared-ptr-instances_6.cpp)]
 
 ## See also
 
 
@@ -69,7 +69,7 @@ struct S {
 
 int main() {
    S  s;   // Declare the object.
-   S& SRef = s;   // Declare the reference.
+   S& SRef = s;   // Declare and initialize the reference.
    s.i = 3;
 
    printf_s("%d\n", s.i);