Namespaces
Variants
Views
Actions

this pointer

From cppreference.com
< cpp‎ | language
Revision as of 02:02, 14 January 2013 by 87.153.239.249 (Talk)

 
 
C++ language
General topics
Flow control
Conditional execution statements
Iteration statements (loops)
Jump statements
Functions
Function declaration
Lambda function declaration
inline specifier
Exception specifications (deprecated)
noexcept specifier (C++11)
Exceptions
Namespaces
Types
Specifiers
decltype (C++11)
auto (C++11)
alignas (C++11)
Storage duration specifiers
Initialization
Expressions
Alternative representations
Literals
Boolean - Integer - Floating-point
Character - String - nullptr (C++11)
User-defined (C++11)
Utilities
Attributes (C++11)
Types
typedef declaration
Type alias declaration (C++11)
Casts
Implicit conversions - Explicit conversions
static_cast - dynamic_cast
const_cast - reinterpret_cast
Memory allocation
Classes
Class-specific function properties
Special member functions
Templates
Miscellaneous
 

Inside non-static member function, holds a pointer to the class object from which the function was invoked.

The type of this pointer is cv T* const where T is the class name and cv refers to the cv specifiers of the function the pointer is used in. For example:

Function signature Type of this
void T::foo()                T* const this;
void T::foo() const          const T* const this;
void T::foo() volatile       volatile T* const this;
void T::foo() const volatile const volatile T* const this;

Example

class T
{
    int x;
 
    void foo()
    {
        this->x = 5; // this used explicitly
        x = 6; // same as this->x = 6;
    }
 
    void foo() const
    {
        this->x = 7; // Error: *this is constant
    }
 
    void foo ( int x )
    {
        // parameter x shadows the attribute with the same name
        this->x = x; // unqualified x refers to the parameter, but the attribute is still accessible using the this pointer 
    }
 
    T& operator= ( const T& b )
    {
        x = b.x;
        return *this; // this is often used when a reference to the current object is needed
    }
 
    void bar ( const T& b )
    {
        // two ways to call class operators using this 
        *this = b;
        this->operator= ( b );
    }
 
    void bar()
    {
       // methods can be called even when there's no object
       // the this pointer can be seen like an additional parameter implicitly passed
       if ( this == NULL )
          return;
    }
};
 
T* pointer = reinterpret_cast<T*>(123);
pointer->bar(); // bar is called with 123 (0x7B) as value for this