Merge pull request #2634 from corob-msft/cr-ko-kr-964

PMEds28 · web-flow · commit 45932d90560d · 2020-01-22T11:38:02.000Z
Add no-loc to this pointer article.
diff --git a/docs/cpp/this-pointer.md b/docs/cpp/this-pointer.md
@@ -1,13 +1,15 @@
 ---
-title: "this Pointer"
-ms.date: "11/04/2016"
+title: "this pointer"
+description: "The this pointer is a compiler-generated pointer to the current object in nonstatic member functions."
+ms.date: "01/22/2020"
 f1_keywords: ["this_cpp"]
 helpviewer_keywords: ["nonstatic member functions [C++]", "pointers, to class instance", "this pointer"]
 ms.assetid: 92e3256a-4ad9-4d46-8be1-d77fad90791f
+no-loc: [this, class, struct, union, sizeof, const, volatile]
 ---
-# this Pointer
+# this pointer
 
-The **this** pointer is a pointer accessible only within the nonstatic member functions of a **class**, **struct**, or **union** type. It points to the object for which the member function is called. Static member functions do not have a **this** pointer.
+The **this** pointer is a pointer accessible only within the nonstatic member functions of a **class**, **struct**, or **union** type. It points to the object for which the member function is called. Static member functions don't have a **this** pointer.
 
 ## Syntax
 
@@ -18,19 +20,19 @@ this->member-identifier
 
 ## Remarks
 
-An object's **this** pointer is not part of the object itself; it is not reflected in the result of a **sizeof** statement on the object. Instead, when a nonstatic member function is called for an object, the address of the object is passed by the compiler as a hidden argument to the function. For example, the following function call:
+An object's **this** pointer isn't part of the object itself. It's not reflected in the result of a **sizeof** statement on the object. When a nonstatic member function is called for an object, the compiler passes the object's address to the function as a hidden argument. For example, the following function call:
 
 ```cpp
 myDate.setMonth( 3 );
 ```
 
-can be interpreted this way:
+can be interpreted as:
 
 ```cpp
 setMonth( &myDate, 3 );
 ```
 
-The object's address is available from within the member function as the **this** pointer. Most uses of **this** are implicit. It is legal, though unnecessary, to explicitly use **this** when referring to members of the class. For example:
+The object's address is available from within the member function as the **this** pointer. Most **this** pointer uses are implicit. It's legal, though unnecessary, to use an explicit **this** when referring to members of the class. For example:
 
 ```cpp
 void Date::setMonth( int mn )
@@ -55,7 +57,7 @@ if (&Object != this) {
 ```
 
 > [!NOTE]
->  Because the **this** pointer is nonmodifiable, assignments to **this** are not allowed. Earlier implementations of C++ allowed assignments to **this**.
+> Because the **this** pointer is nonmodifiable, assignments to the **this** pointer are not allowed. Earlier implementations of C++ allowed assignment to **this**.
 
 Occasionally, the **this** pointer is used directly — for example, to manipulate self-referential data structures, where the address of the current object is required.
 
@@ -131,9 +133,9 @@ your buffer
 
 ## Type of the this pointer
 
-The **this** pointer's type can be modified in the function declaration by the **const** and **volatile** keywords. To declare a function as having the attributes of one or more of these keywords, add the keyword(s) after the function argument list.
+The **this** pointer's type can be modified in the function declaration by the **const** and **volatile** keywords. To declare a function that has either of these attributes, add the keyword(s) after the function argument list.
 
-Consider this example:
+Consider an example:
 
 ```cpp
 // type_of_this_pointer1.cpp
@@ -146,7 +148,7 @@ int main()
 }
 ```
 
-The preceding code declares a member function, `X`, in which the **this** pointer is treated as a **const** pointer to a **const** object. Combinations of *cv-mod-list* options can be used, but they always modify the object pointed to by **this**, not the **this** pointer itself. Therefore, the following declaration declares function `X`; the **this** pointer is a **const** pointer to a **const** object:
+The preceding code declares a member function, `X`, in which the **this** pointer is treated as a **const** pointer to a **const** object. Combinations of *cv-mod-list* options can be used, but they always modify the object pointed to by the **this** pointer, not the pointer itself. The following declaration declares function `X`, where the **this** pointer is a **const** pointer to a **const** object:
 
 ```cpp
 // type_of_this_pointer2.cpp
@@ -159,28 +161,30 @@ int main()
 }
 ```
 
-The type of **this** in a member function is described by the following syntax, where *cv-qualifier-list* is determined from the member functions declarator and can be **const** or **volatile** (or both), and *class-type* is the name of the class:
+The type of **this** in a member function is described by the following syntax. The *cv-qualifier-list* is determined from the member function's declarator. It can be **const** or **volatile** (or both). *class-type* is the name of the class:
 
-*[cv-qualifier-list] class-type*  **&#42; const this**
+[*cv-qualifier-list*] *class-type* **\* const this**
 
-In other words, **this** is always a const pointer; it cannot be reassigned.  The **const** or **volatile** qualifiers used in the member function declaration apply to the class instance pointed to by **this** in the scope of that function.
+In other words, the **this** pointer is always a const pointer. It can't be reassigned.  The **const** or **volatile** qualifiers used in the member function declaration apply to the class instance the **this** pointer points at, in the scope of that function.
 
 The following table explains more about how these modifiers work.
 
-### Semantics of this Modifiers
+### Semantics of this modifiers
 
 |Modifier|Meaning|
 |--------------|-------------|
-|**const**|Cannot change member data; cannot invoke member functions that are not **const**.|
-|**volatile**|Member data is loaded from memory each time it is accessed; disables certain optimizations.|
+|**const**|Can't change member data; can't invoke member functions that aren't **const**.|
+|**volatile**|Member data is loaded from memory each time it's accessed; disables certain optimizations.|
 
-It is an error to pass a **const** object to a member function that is not **const**. Similarly, it is an error to pass a **volatile** object to a member function that is not **volatile**.
+It's an error to pass a **const** object to a member function that isn't **const**.
 
-Member functions declared as **const** cannot change member data — in such functions, the **this** pointer is a pointer to a **const** object.
+Similarly, it's also an error to pass a **volatile** object to a member function that isn't **volatile**.
+
+Member functions declared as **const** can't change member data — in such functions, the **this** pointer is a pointer to a **const** object.
 
 > [!NOTE]
->  Constructors and destructors cannot be declared as **const** or **volatile**. They can, however, be invoked on **const** or **volatile** objects.
+> Constructors and destructors can't be declared as **const** or **volatile**. They can, however, be invoked on **const** or **volatile** objects.
 
 ## See also
 
-[Keywords](../cpp/keywords-cpp.md)
+[Keywords](../cpp/keywords-cpp.md)
