From cppreference.com
Tóm Tắt
edit]
Syntax
this
The expression this
is an rvalue (until C++11)a prvalue (since C++11) expression whose value is the address of the implicit object parameter (object on which the non-static member function is being called). It can appear in the following contexts:
2)
within the
- dynamic exception specification,
(until C++17)
- noexcept specification, and
- the trailing return type
(since C++11)
within the declaration of a non-static member function anywhere after the (optional) cv-qualifier sequence, including
edit]
Explanation
this
can only associate with the innermost enclosing class of its appearance, even if the appearance is invalid in the context:
class
Outer{
int
a[
sizeof(
*
this)
]
;
// error: not inside a member function
unsigned
int
sz=
sizeof(
*
this)
;
// OK: in default member initializer
void
f(
)
{
int
b[
sizeof(
*
this)
]
;
// OK
struct
Inner{
int
c[
sizeof(
*
this)
]
;
// error: not inside a member function of Inner
// 'this' is not associated with Outer
// even if it is inside a member function of Outer
}
;
}
}
;
The type of this
in a member function of class X
is X*
(pointer to X). If the member function is declared with a cv-qualifier sequence cv, the type of this
is cv X*
(pointer to identically cv-qualified X). Since constructors and destructors cannot be declared with cv-qualifiers, the type of this
in them is always X*
, even when constructing or destroying a const object.
When a non-static class member is used in any of the contexts where the this
keyword is allowed (non-static member function bodies, member initializer lists, default member initializers), the implicit this->
is automatically added before the name, resulting in a member access expression (which, if the member is a virtual member function, results in a virtual function call).
In class templates, this
is a dependent expression, and explicit this->
may be used to force another expression to become dependent.
template
<
typename
T>
struct
B{
int
var;
}
;
template
<
typename
T>
struct
D:
B<
T>
{
D(
)
{
// var = 1; // error: 'var' was not declared in this scope
this-
>
var=
1
;
// OK
}
}
;
During construction of an object, if the value of the object or any of its subobjects is accessed through a glvalue that is not obtained, directly or indirectly, from the constructor’s this
pointer, the value of the object or subobject thus obtained is unspecified. In other words, the this pointer cannot be aliased in a constructor:
extern
struct
D d;
struct
D{
D(
int
a)
:
a(
a)
, b(
d.a
)
{
}
// b(a) or b(this->a) would be correct
int
a, b;
}
;
D d=
D(
1
)
;
// because b(d.a) did not obtain a through this, d.b is now unspecified
It is possible to execute delete this;, if the program can guarantee that the object was allocated by new, however, this renders every pointer to the deallocated object invalid, including the this
pointer itself: after delete this; returns, such member function cannot refer to a member of a class (since this involves an implicit dereference of this
) and no other member function may be called.
This is used, for example, in the member function of the control block of std::shared_ptr responsible for decrementing the reference count, when the last reference to the managed object goes out of scope.
(since C++11)
class
ref{
// ...
void
incRef(
)
{
++
mnRef;
}
void
decRef(
)
{
if
(
--
mnRef==
0
)
delete this;
}
}
;
edit]
Keywords
this
edit]
Example
class
T{
int
x;
void
foo(
)
{
x=
6
;
// same as this->x = 6;
this-
>
x=
5
;
// explicit use of this->
}
void
foo(
)
const
{
// x = 7; // Error: *this is constant
}
void
foo(
int
x)
// parameter x shadows the member with the same name
{
this-
>
x=
x;
// unqualified x refers to the parameter
// 'this->' required for disambiguation
}
int
y;
T(
int
x)
:
x(
x)
,// uses parameter x to initialize member x
y(
this-
>
x)
// uses member x to initialize member y
{
}
T&
operator=
(
const
T&
b)
{
x=
b.x
;
return
*
this;
// many overloaded operators return *this
}
}
;
edit]
Defect reports
The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
DR
Applied to
Behavior as published
Correct behavior
CWG 760
C++98
when this
is used in a nested class, it was
unspecified whether it is associated with
the nested class or the enclosing class
this
always associates with
the innermost nested class,
regardless of whether it is in
a non-static member function
CWG 2271
C++98
this
could be aliased when constructing a non-const object
alias is also
prohibited in this case