Lecture 4-7
Classes and Objects
Contents
• Introduction to Classes and Objects
• Class declaration
• Creating Objects
• Accessing Object Members
• Defining Member Functions
• Nesting of Member Function
• Access Specifiers: Public , Private
• Nested Classes
Classes
• Different from structures
– Adds member functions
– Not just member data
• Integral to object-oriented programming
– Focus on objects
• Object: Contains data and operations
• In C++, variables of class type are objects
Specifying a Class
• A class is a way to bind the data and its associated
functions together.
• A class specification has 2 parts:
– Class declaration
– Class function definitions
• Class declaration: describes type and scope of its members.
• Class function definitions: describes how the class functions
are implemented.
General form of Class declaration
Data Hiding
Difference between Structure and
Class
• By default, members of class are private, while, by
default, members of structure are public.
• Encapsulation
• The keywords public and private are known as
visibility labels.
A Simple Class Example
class item
{
int number;
float cost;
public :
void getdata(int a, float b);
void putdata (void);
};
Class Representation
Creating Objects:
item x;
Accessing Class Members:
Object_name.function-name (actual-arguments);
x.getdata(100, 75.5); x.putdata( );
Creating Objects
• Objects can also be created as follows:
Memory Allocation for Objects
• Memory space for objects is allocated when they are
declared and not when the class is specified : partially
true.
• Since all the objects belonging to that class use the same
member functions, no separate space is allocated for
member functions when the objects are created.
• Only space for member variables is allocated separately
for each object. Because, member variables will hold
different data values for different objects.
Example
Defining Member Functions
• Outside the class definition • Inside the class definition
When function is defined inside class, it does
When function is defined outside class, it not require a prototype declaration in the
requires a prototype declaration in the class. class.
Inline Functions
• We can define a member function outside the class definition
and still make it inline by using the qualifier inline in the
header line of the function definition.
Nesting of Member Functions
• An object of a class using dot operator generally calls a
member function of the class.
• However, a member function may also be called by using its
name inside another member function of the same class.
• This is known as “Nesting of Member Functions”
Nesting of Member Functions
Data Hiding Revisited
Access Specifier: Public
• Public members are accessible outside the class.
• Public members are accessible to both member Functions and
non-member Functions.
• Objects can access the members directly using dot operator.
E.g.
– object name.public data member
– object name.public member function
Access Specifier: Public
Access Specifier: Private
• Private Members can only be accessed by the member
functions of that class.
• They cannot be accessed by any non member functions (data
is hidden from outside world).
• Object of a class cannot access private members using dot
operators.
• All data at the beginning of a class is by default private, until
any specifier is mentioned.
Access Specifier: Private
Private Member Functions
Private Member Functions
Nested Classes
• A class is declared within another class.
• The outer class is called enclosing class and inner class
is called the nested class.
• A nested class is a member and as such has the same
access rights as any other member.
• The members of an enclosing class have no special
access to members of a nested class; the usual access
rules shall be obeyed.
Nested Classes Example
#include<iostream>
using namespace std;
class Enclosing /* start of Enclosing class declaration */
{
int x;
class Nested
{ /* start of Nested class declaration */
int y;
void NestedFun(Enclosing e)
{
cout<<e.x; // works fine: nested class can access
// private members of Enclosing class
}
}; // declaration Nested class ends here
}; // declaration Enclosing class ends here
int main(){}
Nested Classes Example
#include<iostream>
using namespace std;
class Enclosing /* start of Enclosing class declaration */
{
int x;
class Nested
{ /* start of Nested class declaration */
int y;
}; // declaration Nested class ends here
void EnclosingFun(Nested n)
{
cout<<n.y; // Compiler Error: y is private in Nested }
}; // declaration Enclosing class ends here
int main(){}
Thank You
