C++ - Unit - I

Dr O.V.Shanmuga Sundaram
Associate Professor in Mathematics

1
Object-Oriented Programming
Introduction to Classes
• Class Definition
• Class Examples
• Objects
• Constructors
• Destructors

2
 Class
• The class is the cornerstone of C++
– It makes possible encapsulation, data hiding and inheritance
• Type
– Concrete representation of a concept
• Eg. float with operations like -, *, + (math real numbers)
• Class
– A user defined type
– Consists of both data and methods
– Defines properties and behavior of that type
• Advantages
– Types matching program concepts
• Game Program (Explosion type)
– Concise program
– Code analysis easy
– Compiler can detect illegal uses of types
• Data Abstraction
– Separate the implementation details from its essential properties
3
 Classes & Objects
Objects: Instance of a class
class Rectangle
{
Rectangle r1;
private: Rectangle r2;
int width; Rectangle r3;

……
int length;
public:
void set(int w, int l);
int area(); int a;
};
4
 Define a Class Type

Header class Rectangle

class class_name {
{ private:
permission_label:
int width;
member;
Body permission_label:
int length;
member; public:
... void set(int w, int l);
}; int area();
};
5
 Class Definition
Data Members
• Can be of any type, built-in or user-defined
• non-static data member
– Each class object has its own copy
• static data member
– Acts as a global variable
– One copy per class type, e.g. counter

6
 Static Data Member
Rectangle r1;
class Rectangle Rectangle r2;
{ Rectangle r3;
private:
int width;
count
int length;
static int count; r1 r2
public: width width
length length
void set(int w, int l);
int area(); width
r3 length
} 7
 Class Definition
Member Functions
• Used to
– access the values of the data members (accessor)
– perform operations on the data members
(implementor)
• Are declared inside the class body
• Their definition can be placed inside the class
body, or outside the class body
• Can access both public and private members of
the class
• Can be referred to using dot or arrow member
access operator
8
 Define a Member Function
class Rectangle
{
private:
int width, length;
class name
public:
void set (int w, int l);
int area() {return width*length; } member function name
};

void Rectangle :: set (int w, int l)

inline {
r1.set(5,8);
width = w;
rp->set(8,10); length = l;
scope operator
}
9
 Class Definition
Member Functions
• const member function
– declaration
• return_type func_name (para_list) const;
– definition
• return_type func_name (para_list) const { … }
• return_type class_name :: func_name (para_list) const { … }
– Makes no modification about the data members (safe
function)
– It is illegal for a const member function to modify a
class data member

10
 Const Member Function
class Time
{
private : function declaration
int hrs, mins, secs ;

public :
void Write ( ) const ; function definition
};

void Time :: Write( ) const

{
cout <<hrs << “:” << mins << “:” << secs << endl;
}

11
 Class Definition - Access Control

• Information hiding
– To prevent the internal representation from direct
access from outside the class
• Access Specifiers
– public
• may be accessible from anywhere within a program
– private
• may be accessed only by the member functions, and friends
of this class
– protected
• acts as public for derived classes
• behaves as private for the rest of the program
12
 class Time Specification
class Time
{
public :
void Set ( int hours , int minutes , int seconds ) ;
void Increment ( ) ;
void Write ( ) const ;
Time ( int initHrs, int initMins, int initSecs ) ; // constructor
Time (); // default constructor
private :
int hrs ;
int mins ;
int secs ;
};
13
13
Class Interface Diagram
Time class

Set
Private data:
Increment
hrs
Write
mins
Time secs

Time

14
 Class Definition
Access Control
• The default access specifier is private
• The data members are usually private or protected
• A private member function is a helper, may only be
accessed by another member function of the same
class (exception friend function)
• The public member functions are part of the class
interface
• Each access control section is optional,
repeatable, and sections may occur in any order

15
 What is an object?

OBJECT
set of methods
Operations (member functions)

Data internal state

(values of private data members)

16
 Declaration of an Object
class Rectangle
main()
{ {
private: Rectangle r1;
Rectangle r2;
int width;
int length; r1.set(5, 8);
public: cout<<r1.area()<<endl;

void set(int w, int l); r2.set(8,10);

int area(); cout<<r2.area()<<endl;
}
};
17
 Another Example
#include <iostream.h> // member function definitions

class circle void circle::store(double r)

{
{ radius = r;
private: }
double radius;
double circle::area(void)
{
public: return 3.14*radius*radius;
void store(double); }
double area(void);
void display(void); void circle::display(void)
{
cout << “r = “ << radius << endl;
}; }

int main(void) {
circle c; // an object of circle class
c.store(5.0);
cout << "The area of circle c is " << c.area() << endl;
c.display(); 18
}
 Declaration of an Object
r1 is statically allocated
class Rectangle
{ main()
private: {
Rectangle r1;
int width;
r1.set(5, 8);
int length;
}
public:
void set(int w, int l); r1
width = 5
int area(); length = 8
};
19
 Declaration of an Object
r2 is a pointer to a Rectangle object
class Rectangle
{ main()
{
private: Rectangle r1;
int width; r1.set(5, 8); //dot notation

int length; Rectangle *r2;

r2 = &r1;
public: r2->set(8,10); //arrow notation
}
void set(int w, int l);
int area(); 5000
r1 r2
width = 8
5 6000
}; length = 10
8 5000
???
20
 Declaration of an Object
r3 is dynamically allocated
class Rectangle
main()
{
{
private: Rectangle *r3;
r3 = new Rectangle();
int width;
r3->set(80,100); //arrow notation
int length;
delete r3;
public: r3 = NULL;
void set(int w, int l); }
int area(); r3
6000 5000
}; NULL
5000
???
width = 80
length = 10021
 Object Initialization
1. By Assignment
#include <iostream.h>
• Only work for public data
class circle members
{ • No control over the operations
public: on data members
double radius;
};
int main()
{
circle c1; // Declare an instance of the class circle
c1.radius = 5; // Initialize by assignment

}
22
 Object Initialization
#include <iostream.h>
class circle
{ 2. By Public Member Functions
private:
double radius;
public:
void set (double r)
{radius = r;}
double get_r ()
{return radius;}
};
int main(void) {
circle c; // an object of circle class
c.set(5.0); // initialize an object with a public member function
cout << "The radius of circle c is " << c.get_r() << endl;
// access a private data member with an accessor 23
}
 Declaration of an Object
r2 is a pointer to a Rectangle object
class Rectangle
{ main()
{
private: Rectangle r1;
int width; r1.set(5, 8); //dot notation

int length; Rectangle *r2;

r2 = &r1;
public: r2->set(8,10); //arrow notation
}
void set(int w, int l);
int area();
r1 and r2 are both initialized by
} public member function set

24
 Object Initialization
3. By Constructor
class Rectangle
{
private: • Default constructor
int width; • Copy constructor
int length;
• Constructor with parameters
public:
Rectangle();
Rectangle(const Rectangle &r); They are publicly accessible
Rectangle(int w, int l); Have the same name as the class
void set(int w, int l); There is no return type
int area(); Are used to initialize class data
} members
They have different signatures
25
 Object Initialization
When a class is declared with no constructors,
the compiler automatically assumes default
class Rectangle constructor and copy constructor for it.
{
• Default constructor
private:
int width;
Rectangle :: Rectangle() { };
int length;
public:
• Copy constructor
void set(int w, int l);
int area(); Rectangle :: Rectangle (const
Rectangle & r)
}; {
width = r.width; length = r.length;
26
};
 Object Initialization
• Initialize with default constructor

class Rectangle
Rectangle r1;
{
Rectangle *r3 = new Rectangle();
private:
int width;
• Initialize with copy constructor
int length;
public: Rectangle r4;
void set(int w, int l); r4.set(60,80);
int area(); Rectangle r5 = r4;
} Rectangle r6(r4);
Rectangle *r7 = new Rectangle(r4);
27
 Object Initialization

class Rectangle If any constructor with any number

of parameters is declared, no default
{
constructor will exist, unless you
private: define it.
int width;
int length;
Rectangle r4; // error
public:
Rectangle(int w, int l)
• Initialize with constructor
{width =w; length=l;}
void set(int w, int l);
Rectangle r5(60,80);
int area();
Rectangle *r6 = new Rectangle(60,80);
}
28
 Object Initialization
Write your own constructors
class Rectangle
{ Rectangle :: Rectangle()
private: {
int width; width = 20;
length = 50;
int length;
};
public:
Rectangle();
Rectangle(int w, int l); Rectangle *r7 = new Rectangle();
void set(int w, int l);
int area(); r7
6000
} 5000
5000
???
width = 20
length = 50 29
 Object Initialization
With constructors, we have more
class Account control over the data members
{
private: Account :: Account(const Account &a)
char *name; {
name = new char[strlen(a.name)+1];
double balance;
strcpy (name, a.name);
unsigned int id; balance = a.balance;
public: id = a.id;
Account(); };
Account(const Account &a);
Account(const char *person); Account :: Account(const char *person)
} {
name = new char[strlen(person)+1];
Account :: Account()
{ strcpy (name, person);
name = NULL; balance = 0.0; balance = 0.0;
id = 0; id = 0;
30
}; };
 So far, …
• An object can be initialized by a class
constructor
– default constructor
– copy constructor
– constructor with parameters
• Resources are allocated when an object is
initialized
• Resources should be revoked when an
object is about to end its lifetime
31
 Cleanup of An Object
Destructor
class Account
{ Account :: ~Account()
{
private:
delete[] name;
char *name; }
double balance;
unsigned int id; //unique
public:
Account(); • Its name is the class name
preceded by a ~ (tilde)
Account(const Account &a); • It has no argument
Account(const char *person); • It is used to release dynamically
~Account(); allocated memory and to perform
other "cleanup" activities
} • It is executed automatically when
the object goes out of scope
32
 Putting Them Together
class Str Str :: Str() {
{ pData = new char[1];
char *pData; *pData = ‘\0’;
int nLength; nLength = 0;
public: };
//constructors
Str(); Str :: Str(char *s) {
Str(char *s); pData = new char[strlen(s)+1];
Str(const Str &str); strcpy(pData, s);
nLength = strlen(s);
//accessors };
char* get_Data();
int get_Len(); Str :: Str(const Str &str) {
int n = str.nLength;
//destructor pData = new char[n+1];
~Str(); nLength = n;
}; strcpy(pData,str.pData);
33
};
 Putting Them Together
class Str
{
char *pData; char* Str :: get_Data()
int nLength; {
return pData;
public:
};
//constructors
Str(); int Str :: get_Len()
Str(char *s); {
Str(const Str &str); return nLength;
};
//accessors
char* get_Data(); Str :: ~Str()
int get_Len(); {
delete[] pData;
//destructor };
~Str();
}; 34
 Putting Them Together
class Str
{
char *pData;
int nLength; int main()
public: {
//constructors int x=3;
Str(); Str *pStr1 = new Str(“Joe”);
Str(char *s); Str *pStr2 = new Str();
Str(const Str &str); }
//accessors
char* get_Data();
int get_Len();
//destructor
~Str();
}; 35
 Interacting Objects
Class A Class B

Private: Private:
data members data members

Member methods Member methods

Public: Public:
Constructor Constructor
Message passing
Destructor Destructor
Other Other
public methods public methods

Private: Private:
methods methods
36
 Working with Multiple Files
• To improve the readability, maintainability and
reusability, codes are organized into modules.
• When working with complicated codes,
– A set of .cpp and .h files for each class groups
• .h file contains the prototype of the class
• .cpp contains the definition/implementation of the class

– A .cpp file containing main() function, should include

all the corresponding .h files where the functions used
in .cpp file are defined

37
 Example : time.h
// SPECIFICATION FILE ( time .h )
// Specifies the data members and
// member functions prototypes.
#ifndef _TIME_H
#define _TIME_H
class Time
{
public:
. . .

private:
. . .
};
#endif
38
 Example : time.cpp
// IMPLEMENTATION FILE ( time.cpp )
// Implements the member functions of class Time

#include <iostream.h>
#include “ time.h” // also must appear in client code
……
bool Time :: Equal ( Time otherTime ) const
// Function value == true, if this time equals otherTime
// == false , otherwise
{
return ( (hrs == otherTime.hrs) && (mins == otherTime.mins)
&& (secs == otherTime.secs) ) ;
}
. . .

39
 Example : main.cpp
// Client Code ( main.cpp )
#include “ time.h”

// other functions, if any

int main()
{
……
}

Compile and Run

g++ -o mainExec main.cpp time.cpp
40
Separate Compilation and Linking of Files
specification file
main program time.h implementation file

main.cpp time.cpp
#include “time.h”

Compiler Compiler

main.o time.o

Linker

mainExec 41