summaryrefslogtreecommitdiffhomepage
path: root/c++.html.markdown
diff options
context:
space:
mode:
authorOllin Boer Bohan <madebyollin@gmail.com>2019-08-31 08:11:27 -0700
committerGitHub <noreply@github.com>2019-08-31 08:11:27 -0700
commit43fc3289dcf623779a30f1002a58748fe3998812 (patch)
treeb9373b317b158353283e82f164d103cfa5447fd9 /c++.html.markdown
parent4e8e92eb0eea94c87575776c2a0f3cea04296f6d (diff)
Minor fixes to C++ Smart Pointer section
* Fix minor spelling / grammar problems ("tp de-allocate", "refences", "dont"...) * Remove filler words ("Basically", "As a matter of fact"...) * Remove spaces before parens in smart pointer initialization code sample (consistent with the other sections, e.g. the `Tuples` section) * Clarify `std::weak_ptr` use case
Diffstat (limited to 'c++.html.markdown')
-rw-r--r--c++.html.markdown46
1 files changed, 23 insertions, 23 deletions
diff --git a/c++.html.markdown b/c++.html.markdown
index 176ea1a8..f3dc8e20 100644
--- a/c++.html.markdown
+++ b/c++.html.markdown
@@ -818,51 +818,51 @@ void doSomethingWithAFile(const std::string& filename)
// Smart Pointer
/////////////////////
-// Generally a smart pointer is a class, which wraps a "raw pointer" (usage of "new"
+// Generally a smart pointer is a class which wraps a "raw pointer" (usage of "new"
// respectively malloc/calloc in C). The goal is to be able to
-// manage the lifetime of the object being point to without explicitly deleting
+// manage the lifetime of the object being pointed to without ever needing to explicitly delete
// the object. The term itself simply describes a set of pointers with the
// mentioned abstraction.
-// Basically smart pointers should preferred over raw pointers, to prevent
-// risky memory leaks, which happens if you forget to delete the object.
+// Smart pointers should preferred over raw pointers, to prevent
+// risky memory leaks, which happen if you forget to delete an object.
// Usage of a raw pointer:
Dog* ptr = new Dog();
ptr->bark();
delete ptr;
-// With the usage of smart pointers you dont have to worry about the deletion
-// of a object anymore.
-// A smart pointer describes a policy, to count the references on the
-// pointer. As matter of fact the objects gets destroyed when the last
-// reference on the object gets destroyed.
+// By using a smart pointer, you don't have to worry about the deletion
+// of the object anymore.
+// A smart pointer describes a policy, to count the references to the
+// pointer. The object gets destroyed when the last
+// reference to the object gets destroyed.
// Usage of "std::shared_ptr":
void foo()
{
-// Its not longer necessary to delete the Dog.
+// It's no longer necessary to delete the Dog.
std::shared_ptr<Dog> doggo(new Dog());
doggo->bark();
}
// Beware of possible circular references!!!
// There will be always a reference, so it will be never destroyed!
-std::shared_ptr<Dog> doggo_one (new Dog());
-std::shared_ptr<Dog> doggo_two (new Dog());
+std::shared_ptr<Dog> doggo_one(new Dog());
+std::shared_ptr<Dog> doggo_two(new Dog());
doggo_one = doggo_two; // p1 references p2
doggo_two = doggo_one; // p2 references p1
-// As mentioned before there is a set of smart pointers. The way you have to
-// use it, is always the same.
-// This leads us to question, when to use which one?
-// std::unique_ptr - use it when you just want to hold one reference on
-// the same object.
-// std::shared_ptr - use it when you want to hold multiple references on the
-// same object and want to make sure that it´s de-allocated
-// when all refences are gone.
-// std::weak_ptr - use it when you want to hold multiple references from
-// different places for references for which it´s no problem
-// tp de-allocate.
+// There are several kinds of smart pointers.
+// The way you have to use them is always the same.
+// This leads us to the question: when should we use each kind of smart pointer?
+// std::unique_ptr - use it when you just want to hold one reference to
+// the object.
+// std::shared_ptr - use it when you want to hold multiple references to the
+// same object and want to make sure that it's deallocated
+// when all references are gone.
+// std::weak_ptr - use it when you want to access
+// the underlying object of a std::shared_ptr without causing that object to stay allocated.
+// Weak pointers are used to prevent circular referencing.
/////////////////////