Defining Member Function

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

Defining Member Functions

Inside the class or outside it with :: — the choice affects inlining, compile times, and how your codebase is organised.

🌍 Where this lives: the header/implementation split you are about to learn is why a large C++ project can take twenty minutes to compile and why changing one line in a widely-included header recompiles everything. Google, Chromium and LLVM all have build engineering teams whose job is partly to fight this. It is also why you can link against a closed-source library: the vendor ships the header with declarations and a compiled .so with the definitions, and your compiler needs nothing more. Search "C++ compilation model translation unit" to see the whole picture — it explains a surprising amount of C++'s oddities.

Two places to put the body

INSIDE the class — implicitly inline: class Circle { double r; public: double area() const { return 3.14159 * r * r; } }; OUTSIDE the class — needs the scope resolution operator: class Circle { double r; public: double area() const; ← declaration }; double Circle::area() const { ← definition return 3.14159 * r * r; } The `Circle::` prefix tells the compiler this function is a MEMBER of Circle, which is what gives the body access to `r` and to the implicit `this`. Omit it and you have defined an unrelated free function that cannot see r. WHEN TO USE WHICH: inside → tiny functions (getters, one-liners); implicitly inline, so no call overhead outside → anything substantial; keeps the class readable as a summary, and putting the definition in a .cpp file means editing it does not force every includer to recompile

two_styles.cpp

#include <iostream>
#include <string>
#include <cmath>

class Triangle {
    double a, b, c;

public:
    /* defined inside — short, implicitly inline */
    Triangle(double x, double y, double z) : a(x), b(y), c(z) {}
    double perimeter() const { return a + b + c; }
    bool   valid()     const { return a+b>c && b+c>a && a+c>b; }

    /* declared here, defined below — substantial bodies */
    double area() const;
    std::string classify() const;
    void   describe() const;
};

double Triangle::area() const {
    if (!valid()) return 0.0;
    double s = perimeter() / 2.0;              /* Heron */
    return std::sqrt(s * (s-a) * (s-b) * (s-c));
}

std::string Triangle::classify() const {
    if (!valid())              return "invalid";
    if (a == b && b == c)      return "equilateral";
    if (a == b || b == c || a == c) return "isosceles";
    return "scalene";
}

void Triangle::describe() const {
    std::cout << a << ", " << b << ", " << c
              << "  " << classify()
              << "  perim=" << perimeter()
              << "  area="  << area() << "\n";
}

int main() {
    Triangle t1(3, 4, 5);
    Triangle t2(5, 5, 5);
    Triangle t3(2, 2, 3);
    Triangle t4(1, 2, 9);       /* impossible */
    t1.describe(); t2.describe(); t3.describe(); t4.describe();
    return 0;
}
Output:
3, 4, 5  scalene  perim=12  area=6
5, 5, 5  equilateral  perim=15  area=10.8253
2, 2, 3  isosceles  perim=7  area=1.98431
1, 2, 9  invalid  perim=12  area=0

Verifying with Heron's formula: A = √(s(s−a)(s−b)(s−c)) Triangle 3,4,5: s = 12/2 = 6 A = √(6 × 3 × 2 × 1) = √36 = 6 ✔ (and 3²+4²=5², so it is right-angled: ½×3×4 = 6 ✔) Triangle 5,5,5: s = 15/2 = 7.5 A = √(7.5 × 2.5 × 2.5 × 2.5) = √117.1875 = 10.8253 ✔ (equilateral check: √3/4 × 5² = 0.4330 × 25 = 10.8253 ✔) Triangle 2,2,3: s = 3.5 A = √(3.5 × 1.5 × 1.5 × 0.5) = √3.9375 = 1.98431 ✔ Triangle 1,2,9: 1 + 2 = 3 < 9, so the triangle inequality fails. valid() returns false and area() returns 0 rather than taking the square root of a negative number — which would be NaN. Guarding before the sqrt is the point.

The hidden `this` pointer

Every non-static member function receives an invisible first parameter: `this`, a pointer to the object it was called on. What you write: What the compiler generates ───────────────────────────────────────────────────────── class C { struct C { int x; }; int x; public: void C_get(C *this) { int get() { return this->x; return x; } } }; c.get(); C_get(&c); So `return x;` is really `return this->x;`. The compiler inserts it. This is why: · one copy of the function code serves every object · sizeof(object) does not grow when you add methods · a static member function has NO this, and therefore cannot access non-static members const member functions receive `const C *this`, which is exactly why they cannot modify members.

this_ptr.cpp

#include <iostream>

class Widget {
    int id;
public:
    Widget(int i) : id(i) {}

    void whoAmI() const {
        std::cout << "id " << id
                  << " (this = " << this << ")\n";
    }
    /* these two lines are identical */
    int  get1() const { return id; }
    int  get2() const { return this->id; }

    /* disambiguating a parameter that shadows a member */
    void setId(int id) { this->id = id; }
};

int main() {
    Widget a(1), b(2);
    a.whoAmI();  b.whoAmI();
    std::cout << "&a = " << &a << "  &b = " << &b << "\n";
    b.setId(99);
    std::cout << "b.get1()=" << b.get1()
              << " b.get2()=" << b.get2() << "\n";
    std::cout << "sizeof(Widget) = " << sizeof(Widget)
              << " (just the int — methods add nothing)\n";
    return 0;
}
Output:
id 1 (this = 0x7ffd1a2b3410)
id 2 (this = 0x7ffd1a2b3414)
&a = 0x7ffd1a2b3410  &b = 0x7ffd1a2b3414
b.get1()=99 b.get2()=99
sizeof(Widget) = 4 (just the int — methods add nothing)

Notice this printed inside whoAmI equals &a printed outside — same object, same address. And sizeof(Widget) is 4 despite four member functions, because the code lives once in the text segment, not per object.

const member functions

double area() const { ... } ↑ this function promises not to modify the object Consequences: · the compiler REJECTS any write to a member inside it · it may be called on a const object; a non-const function may NOT const Circle c(5); c.area(); ✔ area() is const c.setRadius(9); ✗ error: passing 'const Circle' as 'this' argument discards qualifiers THE RULE: mark every member function const that does not modify the object. Not doing so makes your class unusable with const objects and const references — and since `const T&` is the standard parameter type, that means unusable in half of all code. mutable escapes the promise for one member — used for caches and mutexes: class Data { mutable bool cached = false; /* may change in const */ mutable double cache; public: double expensive() const { if (!cached) { cache = compute(); cached = true; } return cache; /* logically const */ } };

constness.cpp

#include <iostream>

class Counter {
    int count = 0;
    mutable int reads = 0;      /* changeable in const fns */
public:
    void increment()      { ++count; }         /* non-const */
    int  get() const      { ++reads; return count; }
    int  readCount() const { return reads; }
};

void observe(const Counter &c) {
    /* c is const here, so only const members are callable */
    std::cout << "observed " << c.get() << "\n";
    /* c.increment();  <-- compile error */
}

int main() {
    Counter c;
    c.increment(); c.increment(); c.increment();
    observe(c); observe(c);
    std::cout << "value " << c.get()
              << ", read " << c.readCount() << " times\n";
    return 0;
}
Output:
observed 3
observed 3
value 3, read 3 times

Const-correctness is worth taking seriously because it propagates. One non-const getter forces every caller that holds a const Counter& to give up, so they take a non-const reference, so their callers do too. Retrofitting const into a large codebase is famously painful for exactly this reason — it is cheap to add up front and expensive to add later.

Worked example — the header/source split

A real project separates the two: // stack.h — the INTERFACE, included by everyone #ifndef STACK_H #define STACK_H class Stack { int data[100]; int top; public: Stack(); bool push(int v); bool pop(int &out); bool empty() const { return top == -1; } /* tiny: inline */ int size() const { return top + 1; } }; #endif // stack.cpp — the IMPLEMENTATION, compiled once #include "stack.h" Stack::Stack() : top(-1) {} bool Stack::push(int v) { if (top >= 99) return false; data[++top] = v; return true; } bool Stack::pop(int &out) { if (top < 0) return false; out = data[top--]; return true; } Why this matters — COMPILE TIME: Change stack.cpp → recompile 1 file, relink. Change stack.h → recompile EVERY file that includes it, transitively. For a 2,000-file project where a header is included by 800 files, that is the difference between a 2-second and a 6-minute build. This is why C++ programmers care about keeping headers thin, and why "put big bodies in the .cpp" is a real engineering rule, not style preference. The #ifndef/#define/#endif is an INCLUDE GUARD: without it, a header included twice in one translation unit would define the class twice — a hard error.

stack_demo.cpp

#include <iostream>

/* single-file version of the split above */
class Stack {
    int data[5];
    int top;
public:
    Stack();
    bool push(int v);
    bool pop(int &out);
    bool empty() const { return top == -1; }
    bool full()  const { return top == 4; }
    int  size()  const { return top + 1; }
};

Stack::Stack() : top(-1) {}

bool Stack::push(int v) {
    if (full()) return false;
    data[++top] = v;
    return true;
}

bool Stack::pop(int &out) {
    if (empty()) return false;
    out = data[top--];
    return true;
}

int main() {
    Stack s;
    for (int i = 10; i <= 70; i += 10)
        std::cout << "push " << i << ": "
                  << (s.push(i) ? "ok" : "FULL")
                  << "  size=" << s.size() << "\n";

    int v;
    std::cout << "popping: ";
    while (s.pop(v)) std::cout << v << " ";
    std::cout << "\nempty now: " << std::boolalpha
              << s.empty() << "\n";
    return 0;
}
Output:
push 10: ok  size=1
push 20: ok  size=2
push 30: ok  size=3
push 40: ok  size=4
push 50: ok  size=5
push 60: FULL  size=5
push 70: FULL  size=5
popping: 50 40 30 20 10
empty now: true

The pops come out reversed — 50 40 30 20 10 — because a stack is LIFO. Note out = data[top--] reads the element and then decrements, which is the postfix-versus-prefix distinction from the pointer topic doing real work here.

🌍 Go further: the recompilation problem above has a classic solution called the pimpl idiom — put a single opaque pointer in the header and every real member in the .cpp, so the header never changes when the implementation does. Qt uses it throughout. C++20's modules are the language-level fix, replacing textual #include with a compiled interface, and they can cut build times by a large factor. Search "pimpl idiom compile firewall" and "C++20 modules vs headers"; both are things a good project would actually use.

💡 Exam angle: show a member function defined both inside and outside the class, and know that the outside form needs ClassName:: and that the inside form is implicitly inline. Explain the this pointer as the hidden first parameter and use it to justify why methods do not increase sizeof and why static functions cannot access non-static members. const member functions are frequently asked — state what they forbid and that only they are callable on a const object.

Syllabus points

Inside vs outside class definition

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.