Class and objects

Class And Objects
Submittedby:
Grp : Zeeb
1.Nafisa Ellahi (2016-2-17-006)
2.Jumma Nahar (2016-2-17-005)
Dept : CSE
Course Title:Object Oriented Programming(OOP-202)
Submitted To: Aysha Aziz
Prova

Cotants:
• C Structures Revisited
• Limitations of C Structure
• An Introduction to classes
• Class definition
• Specifying a class
• Creating objects
• Member Function
• Accessing class members
• Defining Member Functions
• Outside the Class
• Inside the class
• Array of objects
• Memory allocation for objects
• Objects As Function Arguments
• friend Functions and friend Classes

C Structures Revisited
• One of the unique facilities provided by C language
is structure
• It is used to group logically related data items
• It is user defined data-type and once structure type
is defined, variables of that type can be created
3

Limitations of C Structure
• They don’t allow data hiding
• Structure members can be accessed using
structure variable by any function any where in the
scope
• C does not allow the structure data type to be
treated like built-in data type
4

An Introduction to classes
• A class is a building block of OOP. It is the way to bind the data and its logically
related functions together.
• An abstract data type that can be treated like any other built in data type.

Class definition
• Class head class name_of_class.
• Class body {
• data members;
• member functions;
• };

Specifying a class
• Specification of a class consists of two parts:
– Class declaration
– Function definition
Syntax:
class class_name
{
private:
variable declarations
function declarations
public:
variable declarations
function declarations
};
7

Continue…
• The key feature of OOP is data
hiding.
• Generally, data within a class is
made private and the functions are
public.
• So, the data will be safe from
accidental manipulations, while the
functions can be accessed from
outside the class
• However, it is not necessary that
the data must be private and
functions public
8

Creating objects:
• Once a class has been declared, variables of that type can be created
by using the class name as data-type
Test t1; //memory for t1 is allocated
• This statement creates a variable t1 of type test.
• The class variables are known as objects
• t1 is called object of class test.
• More than one object of a class can be created
9

Contd…
Objects are also called instances of class
Objects can be created as follows:
class employee
{
int id;
char name[20];
public:
void getname();
void putname();
}e1, e2, e3;
10

Member Function
• Member function’s name is visible outside the class.
• It can be defined inside or outside the class.
• It can have access to private, public and protected
data members of its class, but cannot access
private data members of another class.

Accessing class members
• The class members are accessed using dot operator
• However it works only for the public members
• The dot operator is called member access operator
• The general format is:
• class-object.class-member;
• Eg: e1.getdata();
• The private data and functions of a class can be accessed only
through the member functions of that class
12

Defining Member Functions
• Member function can be defined in two ways
• Outside the class
• Inside the class
• The code for the function body would be identical in
both the cases i.e perform same task irrespective of
the place of definition
13

Outside the Class
• In this approach, the member functions are only
declared inside the class, whereas its definition is
written outside the class
• General form:
Return-type class-name::function-name(argument-list)
{
--------------
-------------- // function body
--------------
}
14

Contd…
Eg:
class A
{
int x, y;
public:
void getdata ();
// function declaration inside the class}
void A :: getdata()
{
cin>>x>>y; // function body
}
15

Inside the class
• Function body can be included in the class itself by
replacing function declaration by function definition
• If it is done, the function is treated as an inline
function
• Hence, all the restrictions that apply to inline
function, will also apply here
16

Eg:
class A
{
int a, b;
public:
void getdata()
{
cin>>a>>b;}
};
Here, getdata() is defined inside the class. So, it will act like an inline
function
A function defined outside the class can also be made ‘inline’ by using the
qualifier ‘inline’ in the header line of a function definition
17

Array of objects
• Array can be created of any datatype
• Since a class is also a user defined data-type, array
of objects can be created
• Eg: a class Employee is specified. If we have to
keep records of 20 employees in an organization
having two departments, then instead of creating 20
separate variables, we can create array of objects
as follows:
Employee dept1[10];
Employee dept2[10];
18

Memory allocation for objects
• Memory space for object is allocated when they are declared and not
when the class is specified
• The member functions are created and placed in the memory only
once, when they are defined as a part of a class specification
• All the objects belonging to the particular class will use same member
functions when objects are created
• However, the data members will hold different values for different
object, so, space for data member is allocated separately for each
object
19

friend Functions and friend Classes
friend declarations:
To declare a friend function
• Type friend before the function prototype in the class that is giving friendship
friend int myFunction( int x );
should appear in the class giving friendship
• To declare a friend class type friend class Classname in the class that is giving
friendship
• if ClassOne is granting friendship to ClassTwo friend class ClassTwo;
• should appear in ClassOne's definition

Example:
friend
class B {
friend class A ; // A is a friend of B
private:
int i;
};
class A {
public:
A(B b) {
b.i = 0; // legal access due to friendship
}
};

Class and objects

Recommended

More Related Content

What's hot (20)

Similar to Class and objects (20)

Recently uploaded (20)

Class and objects