---
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

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

```cpp
this
this->member-identifier
```

## Remarks

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 as:

```cpp
setMonth( &myDate, 3 );
```

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 )
{
   month = mn;            // These three statements
   this->month = mn;      // are equivalent
   (*this).month = mn;
}
```

The expression `*this` is commonly used to return the current object from a member function:

```cpp
return *this;
```

The **this** pointer is also used to guard against self-reference:

```cpp
if (&Object != this) {
// do not execute in cases of self-reference
```

> [!NOTE]
> 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.

## Example

```cpp
// this_pointer.cpp
// compile with: /EHsc

#include <iostream>
#include <string.h>

using namespace std;

class Buf
{
public:
    Buf( char* szBuffer, size_t sizeOfBuffer );
    Buf& operator=( const Buf & );
    void Display() { cout << buffer << endl; }

private:
    char*   buffer;
    size_t  sizeOfBuffer;
};

Buf::Buf( char* szBuffer, size_t sizeOfBuffer )
{
    sizeOfBuffer++; // account for a NULL terminator

    buffer = new char[ sizeOfBuffer ];
    if (buffer)
    {
        strcpy_s( buffer, sizeOfBuffer, szBuffer );
        sizeOfBuffer = sizeOfBuffer;
    }
}

Buf& Buf::operator=( const Buf &otherbuf )
{
    if( &otherbuf != this )
    {
        if (buffer)
            delete [] buffer;

        sizeOfBuffer =  strlen( otherbuf.buffer ) + 1;
        buffer = new char[sizeOfBuffer];
        strcpy_s( buffer, sizeOfBuffer, otherbuf.buffer );
    }
    return *this;
}

int main()
{
    Buf myBuf( "my buffer", 10 );
    Buf yourBuf( "your buffer", 12 );

    // Display 'my buffer'
    myBuf.Display();

    // assignment operator
    myBuf = yourBuf;

    // Display 'your buffer'
    myBuf.Display();
}
```

```Output
my buffer
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 that has either of these attributes, add the keyword(s) after the function argument list.

Consider an example:

```cpp
// type_of_this_pointer1.cpp
class Point
{
    unsigned X() const;
};
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 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
class Point
{
    unsigned X() const;
};
int main()
{
}
```

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* **\* const this**

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

|Modifier|Meaning|
|--------------|-------------|
|**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's an error to pass a **const** object to a member function that isn't **const**.

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 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)