Type of ‘this’ pointer

by

The type of this pointer is either ClassName * or const ClassName *, depending on whether it is inspected inside a non-const or const method of the class ClassName. Pointer this is not an lvalue.

class ClassName {
  void foo() {
    // here `this` has `ClassName *` type
  }

  void bar() const {
    // here `this` has `const ClassName *` type
  }
};

The observation you mentioned above is misleading. Pointer this is not an lvalue, which means that it cannot possibly have ClassName * const type, i.e. it cannot possible have a const to the right of the *. Non-lvalues of pointer type cannot be const or non-const. There’s simply no such concept in C++ language. What you observed must be an internal quirk of the specific compiler. Formally, it is incorrect.

Here are the relevant quotes from the language specification (emphasis mine)

9.3.2 The this pointer

In the body of a non-static (9.3) member function, the keyword this is
a prvalue expression whose value is the address of the object for
which the function is called. The type of this in a member function of
a class X is X*. If the member function is declared const, the type of
this is const X*, if the member function is declared volatile, the
type of this is volatile X*, and if the member function is declared
const volatile, the type of this is const volatile X*. [ Note: thus in
a const member function, the object for which the function is called
is accessed through a const access path. —end note ]

It is worth nothing that back in the C++98/C++03 times several compilers used an internal implementational trick: they interpreted their this pointers as constant pointers, e.g. ClassName *const in a non-constant method of class ClassName. This apparently helped them to ensure non-modifiablity of this. GCC and MSVC are known to have used the technique. It was a harmless trick, since at language level this was not an lvalue and its constness was undetectable. That extra const would generally reveal itself only in diagnostic messages issued by the compiler.

However, with the advent of rvalue references in C++11 it became possible to detect this extra const on the type of this. For example, the following code is valid in C++11

struct S
{
  void foo() { S *&&r = this; }
};

Yet it will typically fail to compile in implementations that still use the aforementioned trick. GCC has since abandoned the technique. MSVC++ still uses it (as of VS2017), which prevents the above perfectly valid code from compiling in MSVC++.

More Related Contents:

  1. Title Name not showing and background color not changing
  2. Compiler Crash with C++ Array
  3. Is it possible to force c++ class instantiation on the heap?
  4. Pointer to class data member “::*”
  5. When should you use a class vs a struct in C++?
  6. How do I remove code duplication between similar const and non-const member functions?
  7. What is the difference between private and protected members of C++ classes?
  8. Separating class code into a header and cpp file
  9. Static constant string (class member)
  10. How do you pass a member function pointer?
  11. C++ virtual function from constructor [duplicate]
  12. What is the ‘this’ pointer?
  13. C++11 allows in-class initialization of non-static and non-const members. What changed?
  14. How to copy/create derived class instance from a pointer to a polymorphic base class?
  15. How do you create a static class in C++?
  16. Is passing a C++ object into its own constructor legal?
  17. Is it possible to avoid repeating the class name in the implementation file?
  18. Do class functions/variables have to be declared before being used?
  19. What is the difference between a concrete class and an abstract class?
  20. Semicolon after class declaration braces
  21. Pros and cons of using nested C++ classes and enumerations?
  22. Different ways of initializing an object in c++
  23. When do programmers use Empty Base Optimization (EBO)
  24. Wrapping C++ class API for C consumption
  25. Class inherited from class without default constructor
  26. Making a vector of instances of different subclasses
  27. Template type deduction in C++ for Class vs Function?
  28. What is the purpose of forward declaration?
  29. Forward Declaration of variables/classes in std namespace
  30. Same class name in different C++ files

Leave a Comment