Programming and

Computer Applications-2

Introduction to Classes
 Procedural and Object-Oriented
Programming
• Procedural programming focuses on the process/actions
that occur in a program

• Object-Oriented programming is based on the data and the

functions that operate on it.
 Object-Oriented Programming
Terminology
• class: like a struct (allows bundling of related variables),
but variables and functions in the class can have different
properties than in a struct
• object: an instance of a class, in the same way that a
variable can be an instance of a struct
 Classes and Objects
• A Class is like a blueprint and objects are like houses built from
the blueprint
 Object-Oriented Programming
Terminology
• attributes: members of a class

• methods or behaviors: member functions of a class

 Introduction to Classes
• Objects are created from a class
• Format:
class ClassName
{
declaration;
declaration;
};
 Class Example
class Rectangle
{
private:
double width;
double length;
public:
void setWidth(double);
void setLength(double);
double getWidth() const;
double getLength() const;
double getArea() const;
};
 Access Specifiers
• Used to control access to members of the class

• public: can be accessed by functions outside of the class

• private: can only be called by or accessed by functions

that are members of the class
Class Example
Private Members

Public Members
 More on Access Specifiers
• Can be listed in any order in a class

• Can appear multiple times in a class

• If not specified, the default is private

Using const With Member Functions
• const appearing after the parentheses in a member
function declaration specifies that the function will not
change any data in the calling object.

double getWidth() const;

double getLength() const;
double getArea() const;
 Defining a Member Function
• When defining a member function:
• Put prototype in class declaration
• Define function using class name and scope resolution
operator (::)

int Rectangle::setWidth(double w)
{
width = w;
}
 Accessors and Mutators
• Mutator: a member function that stores a value in a private
member variable, or changes its value in some way

• Accessor: function that retrieves a value from a private

member variable. Accessors do not change an object's data,
so they should be marked const.
 Defining an Instance of a Class

• An object is an instance of a class

• Defined like structure variables:
Rectangle r;
• Access members using dot operator:
r.setWidth(5.2);
cout << r.getWidth();
• Compiler error if attempt to access private member using
dot operator
// This program demonstrates a simple class.
#include <iostream>
using namespace std;

// Rectangle class declaration.

class Rectangle
{
private:
double width;
double length;
public:
void setWidth(double);
void setLength(double);
double getWidth() const;
double getLength() const;
double getArea() const;
};
//**************************************************
// setWidth assigns a value to the width member. *
//**************************************************
void Rectangle::setWidth(double w)
{
width = w;
}
//**************************************************
// setLength assigns a value to the length member. *
//**************************************************

void Rectangle::setLength(double len)

{
length = len;
}
//**************************************************
// getWidth returns the value in the width member. *
//**************************************************

double Rectangle::getWidth() const

{
return width;
}
//****************************************************
// getLength returns the value in the length member. *
//****************************************************
double Rectangle::getLength() const
{
return length;
}
//*****************************************************
// getArea returns the product of width times length. *
//*****************************************************

double Rectangle::getArea() const

{
return width * length;
}
//*****************************************************
// Function main *
//*****************************************************
int main()
{
Rectangle r; // Define an instance of the Rectangle class
double rectWidth; // Local variable for width
double rectLength; // Local variable for length

// Get the rectangle's width and length from the user.

cout << "This program will calculate the area of a\n";
cout << "rectangle. What is the width? ";
cin >> rectWidth;
cout << "What is the length? ";
cin >> rectLength;
// Store the width and length of the rectangle
// in the box object.
r.setWidth(rectWidth);
r.setLength(rectLength);

// Display the rectangle's data.

cout << "Here is the rectangle's data:\n";
cout << "Width: " << r.getWidth() << endl;
cout << "Length: " << r.getLength() << endl;
cout << "Area: " << r.getArea() << endl;
return 0;
}
 Inline Member Functions
• Member functions can be defined
• inline: in class declaration
• after the class declaration

• Inline appropriate for short function bodies:

int getWidth() const
{ return width; }
 Constructors
A constructor is a member function of a class which initializes
objects of a class.
In C++,Constructor is automatically called when object(instance
of class) create.
It is special member function of the class.
 Constructors
• Member function that is automatically called when an object
is created

• Purpose is to construct an object

• Constructor function name is class name

• Has no return type

 Default Constructors
• A default constructor is a constructor that takes no
arguments.

• If you write a class with no constructor at all, C++ will write a

default constructor for you, one that does nothing.

• A simple instantiation of a class (with no arguments) calls the

default constructor:
Rectangle r;
 Passing Arguments to Constructors
• To create a constructor that takes arguments:
• indicate parameters in prototype:

Rectangle(double, double);
• Use parameters in the definition:

Rectangle::Rectangle(double w, double len)

{
width = w;
length = len;
}
 Passing Arguments to Constructors
• You can pass arguments to the constructor when you create
an object:

Rectangle r(10, 5);

 Example
// example: class constructor
#include <iostream>
using namespace std;
class Rectangle {
int width, height;
public:
Rectangle (int,int);
int area () {return (width*height);}
};
Rectangle::Rectangle (int a, int b) {
width = a;
height = b;
}
 Example
int main () {
Rectangle r1(3,4);
Rectangle r2(5,6);
cout << "r1 area: " << r1.area() << endl;
cout << "r2 area: " << r2.area() << endl;
return 0;
}

rect area: 12
rectb area: 30
 More About Default Constructors
• If all of a constructor's parameters have default arguments,
then it is a default constructor. For example:

Rectangle(double = 0, double = 0);

• Creating an object and passing no arguments will cause this

constructor to execute:
Rectangle r;
 Destructors
• Member function automatically called when an object is
destroyed
• Destructor name is ~classname, e.g., ~Rectangle
• Has no return type; takes no arguments
• Only one destructor per class, i.e., it cannot be overloaded
• If constructor allocates dynamic memory, destructor should
release it
 Overloading Constructors
• A class can have more than one constructor

• Overloaded constructors in a class must have different

parameter lists:
Rectangle();
Rectangle(double);
Rectangle(double, double);
 Overloading Constructors
// overloading class constructors
#include <iostream>
using namespace std;

class Rectangle {
int width, height;
public:
Rectangle ();
Rectangle (int,int);
int area (void) {return (width*height);}
};
 Overloading Constructors
Rectangle::Rectangle () {
width = 5;
height = 5;
}
Rectangle::Rectangle (int a, int b) {
width = a;
height = b;
}
 Overloading Constructors
int main () {
Rectangle r1(3,4);
Rectangle r2;
cout << "r1 area: " << r1.area() << endl;
cout << "r2 area: " << r2.area() << endl;
return 0;
}

rect area: 12
rectb area: 25
 Only One Default Constructor
and One Destructor
• Do not provide more than one default constructor for a class:
one that takes no arguments and one that has default
arguments for all parameters
Square();
Square(int = 0); // will not compile

• Since a destructor takes no arguments, there can only be one

destructor for a class
 The Unified Modeling Language
• UML stands for Unified Modeling Language.

• The UML provides a set of standard diagrams for graphically

depicting object-oriented systems
 UML Class Diagram

• A UML diagram for a class has three main sections.

Example: A Rectangle Class
class Rectangle
{
private:
double width;
double length;
public:
bool setWidth(double);
bool setLength(double);
double getWidth() const;
double getLength() const;
double getArea() const;
};
 UML Access Specification Notation

• In UML you indicate a private member with a minus (-) and

a public member with a plus(+).

These member variables are private.

These member functions are public.

 UML Data Type Notation

• To indicate the data type of a member variable, place a colon

followed by the name of the data type after the name of the
variable.

- width : double
- length : double
 UML Parameter Type Notation

• To indicate the data type of a function’s parameter variable,

place a colon followed by the name of the data type after the
name of the variable.

+ setWidth(w : double)
 UML Function Return Type Notation
• To indicate the data type of a function’s return value, place a
colon followed by the name of the data type after the function’s
parameter list.

+ setWidth(w : double) : void

The Rectangle Class