Class and Object; Access Specifiers

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

Class and Object; Access Specifiers

A class bundles data with the code that manages it, and access specifiers decide who is allowed to touch what.

🌍 Where this lives: encapsulation is not an academic virtue — it is why software can be maintained at all. When your bank's balance is private, there is exactly one code path that can change it, so exactly one place to audit, log, and validate. Make it public and the balance can be changed from 400 places, and no one can guarantee it never goes negative. Every API you consume works this way: you call fopen and get a FILE* whose internals you cannot see, which is precisely why the C library can rewrite them without breaking your program. Search "encapsulation and the law of Demeter" once this clicks; it is the same idea pushed one step further.

From struct to class

A C struct is data only. A C++ class is data + behaviour + access control. struct Point { int x, y; }; /* C: data */ class Point { /* C++ */ int x, y; ← private by DEFAULT public: void set(int a, int b) { x=a; y=b; } int getX() const { return x; } }; class vs struct in C++ — ONE difference: class → members are PRIVATE by default struct → members are PUBLIC by default Everything else (methods, constructors, inheritance) works identically in both. Convention: use struct for plain data bundles, class when there are invariants to protect. TERMINOLOGY, precisely: CLASS the blueprint / type (written once) OBJECT an instance of the class (created many times) MEMBER a variable or function inside the class METHOD a member function INSTANCE a synonym for object class Student { ... }; ← the class, 0 bytes at runtime Student a, b, c; ← three OBJECTS, real memory

The three access specifiers

public: accessible from ANYWHERE private: accessible only from inside the class (and its friends) protected: accessible from inside the class AND from DERIVED classes — but not from outside own class derived class outside public ✔ ✔ ✔ protected ✔ ✔ ✗ private ✔ ✗ ✗ Access is per-CLASS, not per-OBJECT: class A { int secret; public: void peek(const A &other) { std::cout << other.secret; ← LEGAL. Any A can } read any other A's }; private members. That surprises people, but it is what makes copy constructors and operator== possible to write.

bank.cpp

#include <iostream>
#include <string>

class BankAccount {
    /* private: the class's INVARIANTS live here.
       balance must never go negative — and because
       nothing outside can touch it, that promise holds. */
    std::string owner;
    double      balance;
    int         txn_count;

public:
    BankAccount(const std::string &o, double initial = 0.0)
        : owner(o), balance(initial > 0 ? initial : 0.0),
          txn_count(0) {}

    bool deposit(double amt) {
        if (amt <= 0) return false;      /* validation */
        balance += amt; ++txn_count;
        return true;
    }

    bool withdraw(double amt) {
        /* the invariant is enforced in ONE place */
        if (amt <= 0 || amt > balance) return false;
        balance -= amt; ++txn_count;
        return true;
    }

    /* read-only accessors, const-qualified */
    double getBalance() const { return balance; }
    int    getTxnCount() const { return txn_count; }

    void statement() const {
        std::cout << owner << ": Rs " << balance
                  << "  (" << txn_count << " txns)\n";
    }
};

int main() {
    BankAccount acc("Ram Bahadur", 5000);
    acc.statement();

    std::cout << "deposit  2000 : "
              << (acc.deposit(2000)  ? "ok" : "rejected") << "\n";
    std::cout << "withdraw 3000 : "
              << (acc.withdraw(3000) ? "ok" : "rejected") << "\n";
    std::cout << "withdraw 99999: "
              << (acc.withdraw(99999)? "ok" : "rejected") << "\n";
    std::cout << "deposit  -500 : "
              << (acc.deposit(-500)  ? "ok" : "rejected") << "\n";
    acc.statement();

    /* acc.balance = 1000000;
       error: 'balance' is a private member — and that
       single error message is the whole value of the
       private keyword. */
    return 0;
}
Output:
Ram Bahadur: Rs 5000  (0 txns)
deposit  2000 : ok
withdraw 3000 : ok
withdraw 99999: rejected
deposit  -500 : rejected
Ram Bahadur: Rs 4000  (2 txns)

Tracing the balance: start 5000 + 2000 deposit 7000 txn 1 − 3000 withdraw 4000 txn 2 99999 withdraw rejected — amt > balance −500 deposit rejected — amt <= 0 final 4000, 2 transactions ✔ Notice the two rejections cost nothing and corrupt nothing. With a public balance, `acc.balance -= 99999` would have silently produced −95999 and every downstream report would be wrong. The invariant "balance ≥ 0" is only enforceable because there is exactly ONE door.

This is the actual argument for encapsulation, and it is about counting. With private, the number of places that can break the invariant is the number of member functions — small, listable, reviewable. With public, it is the number of lines in the entire program that mention the object. Encapsulation converts an unbounded audit into a bounded one.

Objects in memory

memory.cpp

#include <iostream>

class Empty { };

class Data {
    int    a;      /* 4 */
    double b;      /* 8 */
    char   c;      /* 1 */
public:
    void method1() { }              /* functions are NOT */
    void method2() { }              /* stored per object  */
    static int shared;              /* ONE for all objects */
};
int Data::shared = 0;

int main() {
    std::cout << "sizeof(Empty) = " << sizeof(Empty)
              << "  (never 0 — every object needs a "
                 "distinct address)\n";
    std::cout << "sizeof(Data)  = " << sizeof(Data)
              << "  (4+8+1 = 13, padded to 24)\n";

    Data d1, d2;
    std::cout << "&d1 = " << &d1 << "\n&d2 = " << &d2 << "\n";
    std::cout << "distinct objects, distinct storage\n";
    return 0;
}
Output:
sizeof(Empty) = 1  (never 0 — every object needs a distinct address)
sizeof(Data)  = 24  (4+8+1 = 13, padded to 24)
&d1 = 0x7ffd1a2b3410
&d2 = 0x7ffd1a2b3428

Working out sizeof(Data) = 24: offset 0 : int a (4 bytes) offset 4 : PADDING (4 bytes) — double needs 8-alignment offset 8 : double b (8 bytes) offset 16: char c (1 byte) offset 17: PADDING (7 bytes) — round up to a multiple of 8, the largest align total = 24 bytes for 13 bytes of data Reorder as { double b; int a; char c; }: offset 0 : b (8), offset 8: a (4), offset 12: c (1), offset 13-15: pad → total 16 bytes. 8 bytes saved. Two things NOT in the object: · member FUNCTIONS — one copy of the code exists, shared by every object. That is why sizeof is unaffected by adding methods. · STATIC members — stored once, in static storage, outside every object. An empty class is 1 byte, not 0, so that two distinct objects have distinct addresses. A class with virtual functions gains a hidden vptr, usually 8 bytes — which is why sizeof jumps when you add `virtual`.

Worked example — encapsulation with a validated invariant

temperature.cpp

#include <iostream>
#include <stdexcept>

class Temperature {
    double celsius;
    static constexpr double ABSOLUTE_ZERO = -273.15;

    /* private helper — implementation detail, not API */
    static bool valid(double c) { return c >= ABSOLUTE_ZERO; }

public:
    explicit Temperature(double c = 0.0) {
        if (!valid(c))
            throw std::out_of_range("below absolute zero");
        celsius = c;
    }

    void setCelsius(double c) {
        if (!valid(c)) return;      /* one gate, always */
        celsius = c;
    }
    void setFahrenheit(double f) {
        setCelsius((f - 32) * 5.0 / 9.0);   /* reuse the gate */
    }

    double getCelsius()    const { return celsius; }
    double getFahrenheit() const { return celsius * 9.0/5.0 + 32; }
    double getKelvin()     const { return celsius - ABSOLUTE_ZERO; }
};

int main() {
    Temperature t(25.0);
    std::cout << t.getCelsius()    << " C = "
              << t.getFahrenheit() << " F = "
              << t.getKelvin()     << " K\n";

    t.setFahrenheit(98.6);
    std::cout << "98.6 F -> " << t.getCelsius() << " C\n";

    t.setCelsius(-500);          /* silently refused */
    std::cout << "after -500 attempt: " << t.getCelsius()
              << " C  (unchanged)\n";

    try { Temperature bad(-300); }
    catch (const std::out_of_range &e) {
        std::cout << "constructor threw: " << e.what() << "\n";
    }
    return 0;
}
Output:
25 C = 77 F = 298.15 K
98.6 F -> 37 C
after -500 attempt: 37 C  (unchanged)
constructor threw: below absolute zero

Checking the conversions: 25 C → F : 25 × 9/5 + 32 = 45 + 32 = 77 ✔ 25 C → K : 25 + 273.15 = 298.15 ✔ 98.6 F → C: (98.6 − 32) × 5/9 = 66.6 × 5/9 = 37 ✔ Note that setFahrenheit does NOT re-implement validation — it converts and delegates to setCelsius. One gate, reused. That is the structural benefit: a new rule added to setCelsius automatically protects every path in. Also note getKelvin can never return a negative number, and you can prove it: celsius ≥ −273.15 is guaranteed by the constructor and by setCelsius, so celsius − (−273.15) ≥ 0. An invariant you can PROVE is the payoff of encapsulation.

🌍 Go further: the getter/setter pattern above is standard exam material but genuinely contested in practice. A class that is nothing but getX/setX for every field has not encapsulated anything — it has just made the fields public with extra typing. The stronger design exposes operations (deposit, withdraw) rather than state (setBalance). Search "anemic domain model" and "tell don't ask principle"; both are direct critiques of getter-heavy design, and understanding them will make your project work noticeably better.

💡 Exam angle: define class versus object precisely (blueprint versus instance), and know the one difference between class and struct in C++ — default access. The three-specifier access table including derived classes is a guaranteed question. Write a class with private data and public accessors enforcing a rule (bank account, temperature, or a date) — that is the standard program. Know that member functions and static members are not stored per object, and that an empty class has size 1.

Syllabus points

Class & object basics
public, private, protected

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.