When should I make explicit use of the `this` pointer?

Question

When should I explicitly write this->member in a method of a class?

Answer 1

There are few cases where using this must be used, and there are others where using the this pointer is one way to solve a problem.

1) Alternatives Available: To resolve ambiguity between local variables and class members, as illustrated by @ASk.

2) No Alternative: To return a pointer or reference to this from a member function. This is frequently done (and should be done) when overloading operator+, operator-, operator=, etc:

class Foo
{
  Foo& operator=(const Foo& rhs)
  {
    return * this;
  }
};

Doing this permits an idiom known as "method chaining", where you perform several operations on an object in one line of code. Such as:

Student st;
st.SetAge (21).SetGender (male).SetClass ("C++ 101");

Some consider this consise, others consider it an abomination. Count me in the latter group.

3) No Alternative: To resolve names in dependant types. This comes up when using templates, as in this example:

#include 


template 
class ValHolder
{
private:
  Val mVal;
public:
  ValHolder (const Val& val)
  :
    mVal (val)
  {
  }
  Val& GetVal() { return mVal; }
};

template 
class ValProcessor
:
  public ValHolder 
{
public:
  ValProcessor (const Val& val)
  :
    ValHolder  (val)
  {
  }

  Val ComputeValue()
  {
//    int ret = 2 * GetVal();  // ERROR:  No member 'GetVal'
    int ret = 4 * this->GetVal();  // OK -- this tells compiler to examine dependant type (ValHolder)
    return ret;
  }
};

int main()
{
  ValProcessor  proc (42);
  const int val = proc.ComputeValue();
  std::cout << val << "\n";
}

4) Alternatives Available: As a part of coding style, to document which variables are member variables as opposed to local variables. I prefer a different naming scheme where member varibales can never have the same name as locals. Currently I'm using mName for members and name for locals.