Unit 3: Classes, objects and constructors

A class has data members (variables) and member functions (methods). Member functions can be defined inside the class or outside using the scope resolution operator ::.

cppclass Account {
private:
    int number;
    double balance;
public:
    void deposit(double amt);            // declared here
    void show() { cout << number << " " << balance; }
};
void Account::deposit(double amt) {      // defined outside
    balance += amt;
}

Objects are declared like variables: Account a1, a2; and members are accessed with the dot operator: a1.show();.

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.

Keeping data private and providing public functions to use it is called data hiding.

• A member function may call another member function of the same class directly by name, without an object or dot operator.

cppclass Marks {
    int m1, m2;
    int total() { return m1 + m2; }          // private helper
public:
    void read() { cin >> m1 >> m2; }
    void show() { cout << "Total " << total() << ", Average " << total() / 2.0; }   // nesting
};

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

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);

cppclass Account {
    long accNo; double balance, rate;
public:
    Account() : accNo(0), balance(0), rate(3.5) {}                     // default
    Account(long n, double b) : accNo(n), balance(b), rate(3.5) {}    // two arguments
    Account(long n, double b, double r) : accNo(n), balance(b), rate(r) {}
    void show() { cout << accNo << ' ' << balance << ' ' << rate << '\n'; }
};
int main() {
    long n; double b;
    cin >> n >> b;
    Account a1, a2(101, 5000), a3(n, b, 4.0);   // dynamic initialisation: values known only at run time
    a3.show();
}

• Constructor overloading lets objects be created in different ways; dynamic initialisation passes run-time values to constructors; the member initialiser list initialises members efficiently.

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.