• friend: a function or class granted access to another class's private/protected members despite not being a member itself — breaks strict encapsulation deliberately for specific, controlled cases
• static member: shared across all objects of a class (one copy total), rather than per-object — accessed via the class name, not requiring an instance
• Object relationships — how classes/objects relate to each other, from loosest to tightest coupling: Association ("uses-a," no ownership), Aggregation ("has-a," weak — the part can exist independently), Composition ("has-a," strong — the part's lifetime is tied to the whole); see the full side-by-side section below for all three with examples
• this pointer: an implicit pointer available inside non-static member functions, pointing to the calling object itself
• const: qualifier preventing modification — const member functions cannot modify the object's data members; const parameters/objects cannot be altered

MCQ Trap: static members belong to the class (one shared copy); non-static (instance) members belong to each object separately.

friend — deliberately breaking encapsulation, in a controlled way

class Box
{
private:
    double width;
public:
    Box(double w) : width(w) {}
    friend void printWidth(Box b);   // grants THIS specific function access to private members
};

void printWidth(Box b)
{
    cout << "Width: " << b.width;   // allowed -- printWidth is a friend, even though it's not a member
}

friend is used sparingly — usually for operator overloading (like operator<<) where the function genuinely needs private access but can't be a member function due to argument order.

static — one copy shared by the whole class

class Employee
{
public:
    static int employeeCount;   // shared across ALL Employee objects
    Employee() { employeeCount++; }
};
int Employee::employeeCount = 0;   // defined outside the class

// Employee::employeeCount accessed via CLASS name, not an object
cout << Employee::employeeCount;

Composition — "has-a" using another class as a member

class Engine { public: void start() { cout << "Engine starts\n"; } };

class Car
{
private:
    Engine engine;   // Car HAS-A Engine -- composition, not inheritance
public:
    void start() { engine.start(); }   // delegates to the contained object
};

Object Relationships, Side by Side — Association, Aggregation & Composition

CSS examiners frequently ask you to "distinguish" between these three — memorize this spectrum, from loosest to tightest coupling:

Association — the loosest relationship

Two classes interact with or know about each other, but neither owns nor is composed of the other.

class Student;   // forward declaration
class Teacher
{
public:
    void teach(Student& s);   // Teacher USES a Student -- association, no ownership
};

Association can be one-directional (only one class knows about the other) or bidirectional (both classes reference each other), and can carry multiplicity (one-to-one, one-to-many, many-to-many) — e.g., one Teacher teaches many Students.