this Pointer

Programming Language & Its Applications — C++ Constructs with Objects and Classes, NEC licence examination syllabus (Nepal Engineering Council).

The `this` Pointer

Every member function secretly receives a pointer to the object it was called on.

🌍 Where this lives: this is what makes method chaining possible, and method chaining is everywhere you look — jQuery's $(x).addClass().fadeIn().show(), SQL query builders like db.table("users").where("age", 18).orderBy("name"), and every "fluent interface" in every language. All of them work by returning a reference to the object itself. Python makes the same pointer explicit as the self parameter you must type out; C++ hides it and calls it this. Search "fluent interface builder pattern" to see how far the idea goes — some libraries build entire configuration DSLs from nothing but returning *this.

What `this` is

Inside a non-static member function of class C: this has type C * const (a const pointer to C) *this is the OBJECT itself this->x is member x of that object In a CONST member function: this has type const C * const → which is exactly why a const function cannot modify members: writing through a const pointer is rejected. The compiler's transformation, made explicit: class Counter { int n; public: void inc() { n++; } }; c.inc(); becomes roughly: void Counter_inc(Counter * const this) { this->n++; } Counter_inc(&c); STATIC member functions have NO this — they are not called on an object. That is the reason they cannot touch non-static members: there is no object to touch.

this_basics.cpp

#include <iostream>

class Box {
    int width, height;
public:
    Box(int w, int h) : width(w), height(h) {}

    /* 1. disambiguating a shadowing parameter */
    void setWidth(int width) {
        this->width = width;      /* member = parameter */
    }

    /* 2. these two are identical */
    int getW1() const { return width; }
    int getW2() const { return this->width; }

    /* 3. passing the object itself to something else */
    void printAddress() const {
        std::cout << "this = " << this << "\n";
    }

    /* 4. comparing identity, not value */
    bool isSameObject(const Box &other) const {
        return this == &other;
    }

    int area() const { return width * height; }
};

int main() {
    Box a(4, 5), b(4, 5);
    a.printAddress();  b.printAddress();

    a.setWidth(10);
    std::cout << "a area = " << a.area()
              << "  (getW1=" << a.getW1()
              << " getW2=" << a.getW2() << ")\n";

    std::cout << std::boolalpha;
    std::cout << "a same as a? " << a.isSameObject(a) << "\n";
    std::cout << "a same as b? " << a.isSameObject(b)
              << "  (equal values, different objects)\n";
    return 0;
}
Output:
this = 0x7ffd1a2b3410
this = 0x7ffd1a2b3418
a area = 50  (getW1=10 getW2=10)
a same as a? true
a same as b? false  (equal values, different objects)

Method chaining — returning `*this`

The distinction that makes chaining work: C& method() { ...; return *this; } → returns a REFERENCE to the SAME object. The next call in the chain acts on the original. C method() { ...; return *this; } → returns a COPY. The next call acts on a temporary, and the changes are thrown away. void method() { ...; } → returns nothing; chaining is a compile error. So the chaining signature is always: ClassName& f(...) And for const-correctness, a chain of read-only operations returns const C& while mutating ones return C&.

chaining.cpp

#include <iostream>
#include <string>

class Query {
    std::string tbl, cond, ord;
    int lim = 0;
public:
    Query& from(const std::string &t)  { tbl  = t; return *this; }
    Query& where(const std::string &c) { cond = c; return *this; }
    Query& orderBy(const std::string &o){ ord = o; return *this; }
    Query& limit(int n)                { lim  = n; return *this; }

    std::string build() const {
        std::string s = "SELECT * FROM " + tbl;
        if (!cond.empty()) s += " WHERE " + cond;
        if (!ord.empty())  s += " ORDER BY " + ord;
        if (lim > 0)       s += " LIMIT " + std::to_string(lim);
        return s;
    }
};

/* the BROKEN version: returns by value */
class BadCounter {
    int n = 0;
public:
    BadCounter inc() { ++n; return *this; }   /* COPY */
    int get() const { return n; }
};

class GoodCounter {
    int n = 0;
public:
    GoodCounter& inc() { ++n; return *this; } /* alias */
    int get() const { return n; }
};

int main() {
    std::cout << Query()
                   .from("students")
                   .where("marks > 80")
                   .orderBy("marks DESC")
                   .limit(10)
                   .build() << "\n";

    BadCounter  bad;   bad.inc().inc().inc();
    GoodCounter good; good.inc().inc().inc();
    std::cout << "bad  = " << bad.get()  << " (expected 3)\n";
    std::cout << "good = " << good.get() << "\n";
    return 0;
}
Output:
SELECT * FROM students WHERE marks > 80 ORDER BY marks DESC LIMIT 10
bad  = 1 (expected 3)
good = 3

Why bad = 1, traced precisely: bad.inc() n becomes 1, returns a COPY (call it T1) T1.inc() T1.n becomes 2 — T1 is a temporary T2.inc() T2.n becomes 3 — also a temporary end of expression T1 and T2 are DESTROYED bad.n was only ever incremented once → 1 With GoodCounter every call returns GoodCounter&, an alias for `good` itself, so all three increments land on the same object → 3. This is one of the few bugs where the code compiles, runs, produces a plausible number, and is silently wrong. The single character `&` in the return type is the whole difference.

Chaining is not the only reason to return *this. Every assignment operator you write must return ClassName& so that a = b = c works — that chain is built into the language's expectations, which is why operator= returning void compiles but breaks idiomatic code.

Worked example — `this` in operator overloading and self-assignment

self_assign.cpp

#include <iostream>
#include <cstring>

class Text {
    char *buf;
    void copyFrom(const char *s) {
        buf = new char[std::strlen(s) + 1];
        std::strcpy(buf, s);
    }
public:
    Text(const char *s = "") { copyFrom(s); }
    Text(const Text &o)      { copyFrom(o.buf); }
    ~Text() { delete[] buf; }

    Text& operator=(const Text &o) {
        /* THE SELF-ASSIGNMENT GUARD.
           Without it, `t = t` deletes buf and then copies
           from the freed pointer — use after free. */
        if (this == &o) return *this;
        delete[] buf;
        copyFrom(o.buf);
        return *this;          /* enables a = b = c */
    }

    Text& append(const char *s) {
        char *nb = new char[std::strlen(buf)+std::strlen(s)+1];
        std::strcpy(nb, buf); std::strcat(nb, s);
        delete[] buf; buf = nb;
        return *this;
    }
    void show() const { std::cout << buf << "\n"; }
};

int main() {
    Text a("Nepal"), b, c;
    b = c = a;                /* chained assignment */
    std::cout << "a="; a.show();
    std::cout << "b="; b.show();
    std::cout << "c="; c.show();

    a = a;                    /* survives thanks to the guard */
    std::cout << "after a=a: "; a.show();

    a.append(" Engineering").append(" Council");
    std::cout << "chained append: "; a.show();
    return 0;
}
Output:
a=Nepal
b=Nepal
c=Nepal
after a=a: Nepal
chained append: Nepal Engineering Council

Why `a = a` is dangerous without the guard: operator=(const Text &o) with this == &o delete[] buf; ← frees the buffer copyFrom(o.buf); ← o.buf IS buf: reads freed memory → undefined behaviour The guard `if (this == &o) return *this;` compares ADDRESSES, not contents. That is the only way to detect self-assignment, and it is only possible because `this` exists. Self-assignment looks contrived, but it happens naturally through references and containers: v[i] = v[j]; /* when i == j */ *p = *q; /* when p == q */ std::sort(...) /* some algorithms self-assign */ The modern alternative is copy-and-swap, which is self-assignment safe without an explicit check: Text& operator=(Text o) { /* by VALUE: copy made */ std::swap(buf, o.buf); /* o destroys the old buf */ return *this; }

Deleting `this` — legal but sharp

delete this; is legal C++, and occasionally correct. class SelfManaged { public: void release() { delete this; } }; SelfManaged *p = new SelfManaged(); p->release(); /* object destroys itself */ Rules if you ever do this: · the object MUST have been created with new · after `delete this`, you may not touch any member and may not use this — the function must return immediately · the caller's pointer is now dangling; set it to nullptr · the object must never be created on the stack, so the destructor is often made private Where it appears legitimately: COM/ActiveX reference counting (`Release()` calls delete this when the count hits zero), and some GUI frameworks where a window deletes itself when closed. Where it does NOT belong: ordinary application code. It is worth recognising in exam questions and in old codebases, not worth writing.

🌍 Go further: this being a pointer rather than a reference is a historical artefact — references were added to C++ after this already existed. In C++11 the picture got richer with ref-qualified member functions, where f() & and f() && let you write different code depending on whether the object is a temporary. And in a lambda, [this] versus [*this] captures a pointer versus a copy — a distinction that causes real dangling-pointer bugs in asynchronous code, since the object may die before the lambda runs. Search "lambda capture this dangling"; it is a live bug class in modern C++.

💡 Exam angle: define this as the implicit pointer to the invoking object and state its type (C* const, or const C* const in a const function). Its three standard uses are asked directly: disambiguating a shadowed member, returning *this for chaining, and the self-assignment check in operator=. Explain why static member functions have no this. The return-by-reference versus return-by-value chaining bug is an excellent trace question.

Syllabus points

Use of this pointer

Create a free account to tick topics off, take notes as you read, watch the video lessons and get a day-by-day study plan built around your exam date.