Unit 2: Class functions and constructors

cppclass Rectangle {
    int l, b;
public:
    void set(int x, int y) { l = x; b = y; }   // defined inside: implicitly inline
    int area();                                  // declared only
};
int Rectangle::area() { return l * b; }          // defined outside using ::

• Scope resolution operator :: links a function to its class, accesses global variables hidden by locals and static members.

• Friend function: a non-member function given access to private members — declared with the keyword friend inside the class; useful for operations on two classes.
• Inline function: the compiler may replace a call with the function body to save call overhead — for small, frequently called functions.
• Static data member: one copy shared by all objects (e.g., a counter); defined outside the class. Static member function: accesses only static members; called with ClassName::function().

cppclass Account {
    static int count;                 // shared by all objects
    double balance;
public:
    Account() { ++count; balance = 0; }
    static int total() { return count; }
    friend void audit(const Account &a);
};
int Account::count = 0;
void audit(const Account &a) { std::cout << a.balance; }   // friend accesses private data

An array of objects stores many objects of the same class: Account acc[10]; Each element is accessed as acc[i].show();.

• By value: a copy is passed — changes inside the function do not affect the caller; the copy constructor is invoked.
• By reference: the function works on the original object (use const reference to avoid copying when no change is needed).

cppvoid raise(Employee e)  { e.salary += 1000; }   // caller unchanged
void raise(Employee &e) { e.salary += 1000; }   // caller changed

A constructor is a special member function with the same name as the class and no return type, called automatically when an object is created. It initialises the object.

Dynamic initialisation means passing values to a constructor at run time (for example values read with cin).

cppclass Point {
    int x, y;
public:
    Point() { x = y = 0; }               // default
    Point(int a, int b) { x = a; y = b; } // parameterised
    Point(const Point &p) { x = p.x; y = p.y; } // copy
};
Point p1, p2(3, 4), p3(p2);

A destructor has the class name preceded by a tilde (~Point()), takes no arguments, has no return type and is called automatically when an object goes out of scope. It releases resources such as memory allocated with new. A class can have only one destructor.