Classes and Objects

Encapsulation is the ability to logically group data and functions together. It is a core pillar of object-oriented programming — it keeps related state and behavior in one unit and controls external access to internals.

Abstraction empowers classes to decide which attributes should be visible outside. It hides implementation details and exposes only what the consumer needs to know. Another pillar of OOP.

class BankAccount {
private:
    double balance;          // hidden — nobody touches this directly
public:
    void deposit(double amt); // exposed — the only way in
    double getBalance();
};

A constructor is a special method invoked automatically when an object is instantiated. It has the same name as the class and no return type. Constructors can be overloaded.

class Student {
public:
    Student();              // default constructor
    Student(std::string n, int age);  // overloaded
};

Defining Outside the Class

You can define a constructor (or any member function) outside the class body using the scope resolution operator :::

Student::Student() {
    // definition
}

Dynamic Allocation

Student* s = new Student();
s->age = 6;  // -> operator dereferences the pointer and accesses the member
delete s;

A default constructor is one that can be invoked without any arguments.

• A class can only have one default constructor
• The compiler automatically generates one if no other constructors are defined
• Defining any constructor (including a copy constructor) suppresses the compiler-generated default — you have to write your own if you still want one
• The compiler-generated default does not initialize primitive data members — they contain garbage values

// Explicitly request the compiler-generated default (C++11)
Student() = default;

// Explicitly delete it to prevent default construction (C++11)
Student() = delete;

An initialization list follows the constructor signature with a colon : and initializes members before the constructor body runs. This is the preferred way to initialize members.

Student(std::string newName, int newAge)
    : name(newName), age(newAge)   // initialization list
{
    // body runs after members are already initialized
}

• Order in the list does not need to match declaration order — members are always initialized in declaration order regardless
• Not all members need to be listed
• Must be used for: const members, reference members, and members whose type has no default constructor

• Always initialize your objects
• Make sure constructors initialize everything
• Assignment is not initialization (for non-built-in types)
• const and reference members must be initialized — they cannot be assigned after construction
• Data members are initialized in the order they are declared in the class, not the order listed in the initializer list

MyClass(int x, int y) : _x(x), _y(y) {}
// members are initialized directly

MyClass(int x, int y) {
    _x = x;  // default-init then assign
    _y = y;  // two operations instead of one
}

Postpone Variable Definitions

Define variables as close to their first use as possible — and initialize them with their needed value immediately, skipping the default-construct-then-assign pattern:

// Not ideal — default constructed, then assigned
Point pt;
pt.x = 5;
pt.y = 5;

// Better — constructed directly with the right values
Point pt2(5, 5);

Loop Variable Tradeoff

Where you declare a loop variable affects how many constructor/destructor calls occur:

// Option A: 1 ctor + 1 dtor + n assignments
Object obj;
for (...) { obj.x = 6; }

// Option B: n ctors + n dtors
for (...) { Object x(6); }

A constructor can delegate to another constructor in the same class via the initialization list, avoiding code duplication:

Student() : Student(" ", 10) {}   // delegates to the 2-arg constructor

A destructor is automatically invoked when an object is destroyed. It has the same name as the class prefixed with a tilde ~, takes no arguments, and returns nothing.

~Student();  // no return, no arguments

Objects are destroyed when:

1. They go out of scope (stack objects)
2. They are explicitly deleted with delete (heap objects)

• Cannot be overloaded — only one destructor per class
• If you don't define one, the compiler generates a no-op destructor

The copy constructor is called when an object is initialized from another object of the same type. The compiler generates one automatically — but it only does a shallow copy.

Shallow Copy (default behaviour)

A shallow copy copies the pointer value — both the original and the copy end up pointing to the same heap memory. Destroying either one leaves the other with a dangling pointer.

Deep Copy (user-defined)

For classes that own heap memory, define your own copy constructor to allocate new memory and copy the data:

// Must be const ref — or the compiler won't accept it
Student(const Student& source);
//       ↑ same name   ↑ pass by ref (to avoid infinite recursion)

When a function returns an object by value, the copy constructor would normally be called to transfer the data — but for temporary objects this is wasteful. A move constructor lets you "steal" the resource instead of copying it.

Student(Student&& moveSource);
//      ↑ rvalue reference (&&) — binds to temporaries

Student myFunc();
Student newStudent(myFunc());   // move constructor invoked, not copy

If your class needs to define any one of these, it almost certainly needs to define all of them — because the need for one implies you're managing a resource that all of them must handle correctly.

Non-Copyable Classes

To prevent an object from being copied, declare the copy constructor and copy assignment operator as private (pre-C++11) or = delete (C++11, preferred):

class Unique {
    Unique(const Unique&) = delete;
    Unique& operator=(const Unique&) = delete;
};

Singleton Classes

A singleton permits exactly one instance of a class:

1. Make the constructor, copy constructor, and assignment operator private
2. Provide a public static method that returns the single instance
3. Store the instance as a static variable inside that method

class Config {
public:
    static Config& GetInstance() {
        static Config instance;  // created once, lives forever
        return instance;
    }
private:
    Config() {}
    Config(const Config&) = delete;
};

Heap-Only Classes

To prevent stack instantiation, make the destructor private. Only heap instances are then allowed by the compiler. Provide a public static destroy function to allow deletion:

static void Destroy(Student* instance) {
    delete instance;  // valid — we're inside the class, so private dtor is accessible
}

Static members belong to the class, not to any individual instance. They are shared across all objects of that type.

• Static data members — one copy shared by all instances. A static variable inside a method retains its value between calls.
• Static member functions — shared across all instances. Can only access other static members (no this pointer).

class Student {
public:
    static int count;
};

// Must be defined and initialized outside the class
int Student::count = 0;

A static object exists from the time it is constructed until the end of the program. There are two kinds:

The fix: wrap non-local statics inside functions (making them local statics). They are guaranteed to be initialized the first time the function is called:

MyClass& getInstance() {
    static MyClass instance;  // initialized on first call, safe
    return instance;
}

A constructor that takes a single argument acts as an implicit conversion constructor — the compiler will use it to automatically convert from that argument type to the class type.

class Student {
public:
    Student(int age);  // single-argument constructor
};

void CheckStudent(Student s);

CheckStudent(10);     // ALLOWED — 10 is implicitly converted to Student(10)
Student s = 30;     // ALLOWED — implicit conversion constructor

Preventing Implicit Conversions with explicit

Mark the constructor explicit to require that conversion to be written out:

explicit Student(int age);

CheckStudent(10);          // ERROR — implicit conversion blocked
CheckStudent(Student(10));  // OK — explicit construction

Const Member Functions

Member functions can be overloaded on const alone — a trailing const after the parameter list signals that the function will not modify any member variables:

{
public:
    void myFunc();
    void myFunc() const; // overloaded const version
}

Bitwise vs. Logical const

const member functions are bitwise const — the bits of the object are unchanged — but not necessarily logically const (they might modify data through a pointer member).

Use the mutable keyword to allow a specific member to change inside a const function — useful for caches or lazy-computed values:

{
public:
    void myFunc() const;
private:
    int var1;
    mutable int var2; // can be edited even inside myFunc() const
}

The friend keyword grants an external function or class access to a class's private and protected members.

class Student {
private:
    int grade;
    friend void CalcArea();   // CalcArea can access Student's privates
    friend class Teacher;    // the entire Teacher class can access privates
};

A union is a special class type where all non-static data members share the same memory location. Only one member is "active" at any given time — writing to one member invalidates all others.

• The last member you set is the only valid one to read
• The size of a union equals the size of its largest member

union Variant {
    int   i;
    float f;
    char  c;
};  // sizeof(Variant) == sizeof(float) == 4

Variant v;
v.i = 42;    // i is active
v.f = 3.14;  // f is now active — reading v.i is undefined behavior

Aggregate initialization lets you initialize an object's members with a brace-list, like an array:

Student newStudent = {"Peter", 28};  // name = "Peter", age = 28

A class is an aggregate only if it has all of:

• Public data members
• Non-static members only
• No private data
• No virtual functions
• Only public inheritance (or none)
• No user-defined constructors

A constexpr constructor tells the compiler to evaluate the creation and instances of the class at compile time wherever possible.

constexpr Student(int age);

• Member variables become implicitly const
• Member functions become implicitly inline
• When called with literal arguments, the object can be fully constructed at compile time with zero runtime cost

A class defined inside another class. The inner class has access to all members of the enclosing class, but does not have access to the enclosing class's this pointer (unless given a reference to an instance).

class Student {
    int x;
public:
    class Inner {
        void foo() { x = 5; }  // can access Student::x
    };
};

Defining the inner class's methods outside requires two scope operators:

void Student::Inner::foo() { /* ... */ }

Within the body of any non-static member function, an implicit this pointer is passed as a hidden parameter. It points to the object that is calling the member function.

class Student {
    std::string name;
public:
    Student& setName(std::string n) {
        this->name = n;  // disambiguates member from parameter
        return *this;   // enables method chaining
    }
};