9.

Objects and Classes

9. Objects and Classes

Object-oriented programming (OOP) involves programming using objects.

CREATING AN OBJECT:

The state (properties or attributes) of an object is represented by data fields with their current

values. The behavior (actions) of an object is defined by functions. For example, a circle object

has a data field, radius, which is the property that characterize a circle. We may define a function

named getArea() for circle object to return the area of the circle.

An instance of a class is an object. Instantiation is creating an instance. We may create many

instances of a class.

A C++ class uses variables to define data fields and functions to define behaviors.

Constructors are functions of a special type that a class provides to perform initializing actions.

Constructors must have three properties:

• Have the same name as the class itself.

• Do not have a return type, not even void.

• Invoked when an object is created.

Class Variable vs Instance Variable:

The class variable is the variable which is associated to the class (its value is not changed when

instantiation) while the instance variable is the variable which is associated to the instance

(different instances of the same object has different values of the instance variable).

-1-
 9. Objects and Classes
#include <iostream>
using namespace std;

class Circle{
public:
double pi = 3.14159; // Class variable
double radius; // Instance variable
// Construct a circle object without arguments
Circle(){
radius = 1;
}
// Construct a circle object with arguments
Circle(double newRadius){
radius = newRadius;
}
// Return the area of this circle
double getArea(){
return radius * radius * pi;
}
}; // Must place a semicolon here

int main(){

Circle circle1; // Create a circle object whose radius is 1

Circle circle2(5); // Create a circle object whose radius is 5

cout << circle1.radius << endl;

cout << circle2.getArea() << endl;

circle2.radius = 2; // Modify the radius of circle2 Circle object

cout << circle2.getArea() << endl;

return 0;
}

NB. A semicolon (;) is essential to be places after the closing curly brackets (}) of defining a

class.

-2-
 9. Objects and Classes
ACCESS OBJECT’S DATA AND FUNCTIONS:

After an object is created, its data can be accessed and its functions invoked using the dot operator

(.), also known as the object member access operator. The data field is referred to as instance

member variable or simply instance variable while the function is referred to as instance member

function or instance function. A calling object is an object on which an instance function is

invoked.

Data fields may be initialized in the constructor using an initializer list:

...

class Circle{
public:
double radius;
Circle()
: radius(1) // No semicolon here
{
// Additional statement if needed
}
Circle(double newRadius){
: radius(newRadius) // No semicolon here
{}
}; // Must place a semicolon here

NB. A class may be defined without constructors. In this case, a no-arguments constructor, called

default constructor, with an empty body is implicitly defined in the class.

...

class Circle{
public:
double radius;
// Implicitly a default constructor with no arguments is defined

/*
Circle(){

-3-
 9. Objects and Classes
}
*/

// Return the area of this circle

double getArea(){
return radius * 3.14159;
}
}; // Must place a semicolon here

Anonymous object is an object which is created without naming it to use it only once.

...

int main(){
// Create anonymous objects
cout << Circle().radius << endl;
cout << circle(5).getArea() << endl;

return 0;
}

NB. In C++, to create anonymous object using no-arguments constructor, we have to add

parentheses after the constructor name (e.g., Circle()) while creating a named object using no-

arguments constructor, we cannot use parentheses after the constructor name (e.g., Circle

circle1).

NOTES:

• A class is also a data type.

• We can use either primitive data types or another class to define the class data fields.

• We can use the assignment (=) operator to copy the contents from one object to the other.

• The object name is constant. It cannot be reassigned to represent another object.

-4-
 9. Objects and Classes
SEPARATING CLASS DEFINITION FROM IMPLEMENTATION:

Importance of :

• It makes the class easy to maintain.

• It protects the software provider’s intellectual property as it hides the source code.

Class definition Class implementation

• Lists all the data fields
• Lists constructor prototypes Determine how the class operates
• Lists function prototypes
File extension is .h File extension is .cpp

Circle.h
class Circle{
public:
// The radius of the circle
double radius;
// Construct a default circle object
Circle();
// Construct a circle object
Circle(double);
// A function that return the area of the circle
double getArea();
};

Circle.cpp
#include "Circle.h"
// How to construct a circle object with a default radius = 1
Circle::Circle()
{
radius = 1;
}
// How to construct a circle object with a specific radius
Circle::Circle(double newRadius)
{
radius = newRadius;
}
// How to calculate and return the area of the circle

-5-
 9. Objects and Classes
double Circle::getArea()
{
return radius * 3.14159;
}

main.cpp
#include <iostream>
#include "Circle.h"

using namespace std;

int main(){
Circle circle1;
Circle circle2(5);
cout << circle1.getArea() << endl;
cout << circle2.getArea() << endl;
return 0;
}

NB. The :: symbol is known as binary scope resolution operator which specifies the scope of a

class member in a class. Circle:: preceding each constructor and function is the Circle class

tells the compiler that these constructors and functions are defined in the Circle class.

NB. Such a program that uses the class is often referred to as a client of the class.

PREVENTING MULTIPLE INCLUSIONS:

Inclusion guard prevents header files to be included multiple times. Including a header file

multiple times results in a compile error indicating that there are multiple definitions for the

header.

Circle.h
#ifndef CIRCLE_H // Stands for if not defined
#define CIRCLE_H

class Circle{

-6-
 9. Objects and Classes
public:
// The radius of the circle
double radius;
// Construct a default circle object
Circle();
// Construct a circle object
Circle(double);
// A function that return the area of the circle
double getArea();
};

#endif

Head.h
#include "Circle.h"

Circle.cpp
#include "Circle.h"
#include "Head.h"
// How to construct a circle object with a default radius = 1
Circle::Circle()
{
radius = 1;
}
// How to construct a circle object with a specific radius
Circle::Circle(double newRadius)
{
radius = newRadius;
}
// How to calculate and return the area of the circle
double Circle::getArea()
{
return radius * 3.14159;
}

main.cpp
#include <iostream>
#include "Circle.h"

using namespace std;

-7-
 9. Objects and Classes

int main(){
Circle circle1(5);
cout << circle1.getArea() << endl;
return 0;
}

NB. Any statement preceded by the sign (#) is preprocessor directive.

INLINE FUNCTIONS IN CLASSES:

When the function is implemented inside a class definition, it automatically becomes an inline

function. This is also known as inline definition that improve performance. To make the function

an inline function in the implementation file, the function is preceded by inline keyword.

Circle.h
#ifndef CIRCLE_H // Stands for if not defined
#define CIRCLE_H

class Circle{
public:
// The radius of the circle
double radius;
// Construct a default circle object
Circle() // Inline definition
{
r = 1;
}
// Construct a circle object
Circle(double);
// A function that return the circumference of the circle
double getCircumference() // Inline definition
{
return 2 * r * 3.14159;
}
// A function that return the area of the circle
double getArea();
};

inline double Circle::getArea() // Inline definition

-8-
 9. Objects and Classes
{
return radius * 3.14159;
}

#endif

Circle.cpp
#include "Circle.h"
#include "Head.h"
// How to construct a circle object with a default radius = 1
// How to construct a circle object with a specific radius
Circle::Circle(double newRadius) // Not inline definition
{
radius = newRadius;
}

DATA FIELD ENCAPSULATION:

Encapsulation is bundling of data with the mechanisms or methods that operate on the data while

information hiding is making the data fields private protects data and makes the class easy to

maintain.

Cons of public data fields:

• Data may be tampered with.

• It makes the class difficult to maintain and vulnerable to bugs.

NB. The private data field cannot be accessed or modified unlike the public one which can be

accessed and modified.

Circle.h
#ifndef CIRCLE_H // Stands for if not defined
#define CIRCLE_H

class Circle{
private:
-9-
 9. Objects and Classes
// The radius of the circle
double r; // The r variable cannot be accessed or modified
public:
// Construct a default circle object
Circle()
{
r = 1;
}

// Construct a circle object

Circle(double);

// A function that return the area of the circle

double getArea();
};

#endif

To make the private data field accessible, we provide get (accessor) function. To enable updating

of a private data field, we provide set (mutator) function.

Circle.h
#ifndef CIRCLE_H // Stands for if not defined
#define CIRCLE_H

class Circle{
private:
// The radius of the circle
double r; // The r variable cannot be accessed or modified
public:
// Construct a default circle object
Circle()
{
r = 1;
}
// Construct a circle object
Circle(double);
// Define a get function to return the private r variable
double getR()
{
return r;
}

- 10 -
 9. Objects and Classes
// Define a set function to update the private r variable
void setR(double newR)
{
r = newR;
}
// A function that return the area of the circle
double getArea();
};

#endif

CLASS ABSTRACTION AND ENCAPSULATION:

Class abstraction is the separation of class implementation from the use of a class. Class

encapsulation is hiding the details of implementation through encapsulation. Class abstraction

and encapsulation are two sides of the same coin.

NB. The creator of a class provides a description of the class and lets the user know how it can be

used.

THE SCOPE OF VARIABLES:

The scope of instance and static variables is the entire class, regardless of where the variables are

declared. Global variables are declared outside all functions and are accessible to all functions

in its scope. The scope of a global variable starts from its declaration and continues to the end

of the program. Local variables are defined inside functions. The scope of a local variable starts

from its declaration and continues to the end of the block that contains the variable.

NB. The data fields are declared as variables and are accessible to all constructors and functions

in the class.

- 11 -
 9. Objects and Classes
Representation Invariant:

The representation invariant is a condition that must be true over all valid instances of a class.

- 12 -
 Python Classes
Python has a number of special method:

__init__ when invoked, it creates vals which is an object of type list. When a new object is

created, it is bound to the formal parameter self.

class InSet(object):

def __init__(self):
self.vals = []

__str__ is used to return a string when invoking the print() function to print the object.

class InSet(object):

def __init__(self):
self.vals = []

def __str__(self):
result = ""
for i in self.vals:
result = result + ", " + str(i)
return "{" + result[2:] + "}"

__it__ allows for the overloading of the less-than operator (<) for custom objects.

Class Variable vs Instance Variable:

class Circle(object):

pi = 3.14159 ## pi is a class variable

def __init__(self, r=1):

self.r = r ## r is an instance variable

def getR(self):
return self.r

def getArea(self):
return self.r * self.r * Circle.pi

- 13 -
 Python Classes

def __str__(self):
return "Circle area is " + str(self.getArea())

Representation Invariant:

The representation invariant for IntSet is that vals contains no duplicates.

class InSet(object):

def __init__(self):
self.vals = []

def insert(self, e):

if e not in self.vals:
self.vals.append(e)
else:
return str(e) + " is already in the set"

def member(self, e):

return e in self.vals

def remove(self, e):

try:
self.vals.remove(e)
except:
raise ValueError(str(e) + " isn't in the set")

def getMembers(self):
return self.vals[:]

def __str__(self):
result = ""
self.vals.sort()
for e in self.vals:
result = result + str(e) + ', '
return '{' + result[:-2] + '}'

- 14 -
 Python Classes
Inheritance:

Inheritance provides a convenient mechanism for building groups of related abstractions.

The subclass inherits the attributes (properties) of its superclass. In addition, the subclass can

override attributes of its superclass.

Circle.py
class Circle(object):

pi = 3.14159

def __init__(self, r=1):

self.r = r

def getR(self):
return self.r

def getArea(self):
return self.r * self.r * Circle.pi

def __str__(self):
return "Circle area is " + str(self.getArea())

Square.py
from Circle import Circle

class Square(Circle):

def __init__(self, r=1):

Circle.__init__(self, r)

def getArea(self): ## Override the function getArea()

return self.r * self.r

def __str__(self): ## Override the function __str__

return "Suqare area is " + str(self.getArea())

- 15 -
 Python Classes
Information hiding:

To make the variable or the function private and invisible outside the class, put (__) before the

variable or the function but not after it.

class Circle(object):
)
__pi = 3.14159
## __pi is an invisible (private) class variable
## which cannot be accessed outside the class

def __init__(self, r=1):

self.r = r

def getR(self):
return self.r

def getArea(self):
return self.r * self.r * Circle.pi

def __str__(self):
return "Circle area is " + str(self.getArea())

NB. When a subclass attempts to use a hidden attribute of its superclass an AttributeError

occurs.

NB. It is not unusual during the creation and later maintenance of a program to go back and add

new classes or new attributes to old classes. Good programmers design their programs so as to

minimize the amount of code that might need to be changed when that is done.

Python built-in functions:

isinstance(instanceName, objectName) this returns True or False.

- 16 -