Major terminologies in oop (Lect 2).ppt. Object oriented programming

OOP concepts
When you approach a programming problem in an
object oriented language, you no longer ask how
the problem will be divided into functions but how
it will be divided into objects:
Thinking in terms of objects rather than functions has
helpful effect on how easily you can design
programs, because the real world consists of
objects and there is a close match between objects
in the programming sense and objects in the real
world

Ct’d
What is object?
Many real-world objects have both attribute (xtics that can
change) abilities or responsibilities- (things they can do)
Real-world object = Attributes(state) + Abilities(behavior,
responsibility)
Programming object = Data + Functions
The match between programming object and real-world
objects is the result of combining data and member
functions
How is object defined in C++ program?

Classes and Objects
• Class is a new data type which is used to define objects. A
class serves as a plan , or a template. It specifies what data
and what functions will be included in objects of that class.
Writing a class does not create any objects.
• A class is a description of similar objects
• Objects are instances of classes
• Example: A model (class) to define points in a graphics
program.
Points on a plane must have two properties (states):
– X and y coordinates. we can use two integer variables to
represent these properties.

Ct’d
in our program, points should have the following abilities
(responsibilities):
• Point can move on the plane : move function
• Point can show their coordinates on the screen: print
function
• Point can answer the question whether they are on the
zero point (00) or not: is_zero function

Example point class:
Class point{ // Declaration of point class
Int x,y; // attribute: x and y coordinates .. Attributes
Public: // we will discuss later
void move(int, int); // A function to move the points ..
Behavior
void print(); // to print the coordinates on the screen ..
responsibilities
Bool is _zero(0; //is the point on the zero point (00)
}; // End of class declaration (; must be there)

In our example first data and then the function prototype s
are written . It is also possible to write them in reverse
order.
Data and function s in a class are called members of the class
In our example only the prototypes of the functions are
written in the class declaration. The bodies may take place
in other parts (in other files) of the program.
If the body of a function is written in the class declaration.
Then this function is defined as an inline function(macro).

// ****Bodies of Member Functions****
// a function to move the points
void point::move(int new_x,int new_y)
{
X=new_x; // assigns new value to x coorrdinate
y = new_y; // assigns new value to y coordinate
}
// To print the coordinate on the screen
Void point::print()
{
Cout<<“X= “ <<x<<“,Y= “ <<y << endl;
}

Ct’d
// is the point on the zero point(00)
Bool point::is_zero()
{
return (x ==0) &&(y ==0); // if x=0 AND y=0 returns true
}

Now we have a model (template) to define point objects. We
can create necessary point (objects) using the model.
int main()
{
Point.point1, point2; //2 object are defined: point1 and point2
Point1.move(100,50); // point1 moves to (100,50)
Point1.print(); // point1 coordinate to the screen
Point1.move(20,65); // point1moves to (20,65)
poit1,.print(); // point1’s coordinates on the screen
If (piont1.is_zero()) // is point1 on (00)?
cout <<“point1 is now on zero point(00)” << endl;

else
cout << “ point1 is NOT on zero point(00)” << endl;
point2.move(00); // point2 moves to (00)
if (point2.is_zero()) // is point2 on (00)?
cout << “point2 is now on zero point(00)” << endl;
else
cout <<“ point2 is NOT on zero point (00) << endl;
return o;
}

C++ Terminology
• A class is a grouping of data and functions. A class is very
much like a structure type as used in ANSI-C, it is only a
pattern (a template) to be used to create a variables which
can be manipulated in a program
Classes are design to give certain services
• An object is an instance of a class, which is similar to a
variable defined as an instance of a type. An object is what
you actually use in a program
• An attribute is a data member of a class that can take
different values for different instances (objects) of this
class. Example; Name of a student, coordinates of a point

Ct’d
• A methods (member function) is a function contained
within the class . You will find the functions used within a
class often referred to as methods in programming
literature
classes fulfill their services (responsibilities) by the help of
their methods.
• A message is the same thing as a function call. In object
oriented programming , we send messages instead of
calling functions. For the time being , you can think of
them as identical. Later we will see that they are in fact
slightly different
messages are sent to object to get some services from them.

conclusion
until now that we have discovered some features of the oop
and the c++.
Our programs consist of object as the real world do.
Classes are living (active) data types which are used to
defined objects. We can send messages (orders) to objects
to enable them to do something .
Classes include both data and the functions involved with
these data (encapsulation).As the result:
• Software object are similar to the real world objects
• Programs are easy to read and understand.
• It is easy to find errors
• It supports modularity and teamwork

Defining object as inline Functions
(macro)
In the previous example, only the prototypes of the member
functions are written in the class declaration. The bodies of
the methods are defined outside the class.
It is also possible to write bodies of methods in the class. Such
methods are defined as inline functions
For example the is_zero method of the point class can be
define as an inline function as follows:
class point { //Declaration of point class
int x,y; // properties: x and y coordinates
public:
void move(int, int); // to print the coordinates on the
screen

Ct’d
void print(); // to print the coordinates on the screen
bool is_zero() // is the point on the zero point(0,0) inline
function
{
return (x ==0) &&(y == 0); // the body of is _zero
}
};
NB: Do not write long methods in the class declaration. It
decreases the readability and the performance of the
program

Defining Dynamic Objects
Classes can be used to define variable like built-in data type
(int, float,char etc) of the compiler.
For example it is possible to define pointers to objects. In the
example below two pointers (ptr1 and ptr2) to objects of
type point are defined.
Int main()
{
Point*ptr1 = new point; // allocating memory for the
object pointed by ptr1
Point*ptr2 = new point; // allocating memory for the
object pointed by ptr2

Ct’d
ptr1->move(50,50); //’move’ message to the object
pointed by ptr1
Ptr1->print(); // ‘print’ message to the object pointed
by ptr1
Ptr2->move(100,150); // ‘move’ message to the object
pointed by ptr2
If (ptr2->is_zer0()) // is the object pointed by ptr2 on zero
cout<<“Object pointed by ptr2 is NOT on zero.”<<endl;
delete ptr1 // Releasing the memory
delete ptr2;
return 0;
}

Defining array of Objects
We may define static and dynamic array of objects. In the next
example below we shall see later how to define dynamic array of
objects
int main()
{
Point array[10]; //defining an array with ten objects
Array[0].move(15,40); // ‘move message to the first element
(indices 0)
Array[1].move(75,35); //’move’ message to the second
element (indices 1)
:
for (int i =0; i < 10; i ++) // ‘print’ message to all objects in the array

Ct’d
array[i].print();
return 0;
}

Controlling Access to Members
we can divide programmers into two groups: classs creators (those
who create new data type) and client programmers (the class
consumers who use the data types in their applications)
The goal of the class creator is to build a class that includes all necessary
to the client programmer and keeps everything else hidden
The goal of thee client programmer is to collect a toolbox full of classes
to use for rapid application development
The first reason for access control is to keep client programmer’s hands
off portions they shouldn’t touch. The hidden parts are only
necessary for the internal machinations of the data type but not part
of the interface that users need in order to solve their particular
problems

Ct’d
the second reason for access control is that. If it’s hidden, the
client programmer can’t use it , which means that the class
creator can change the hidden portion at will without
worrying a bout the impact to anyone else.
This protection also prevent accidentally changes of states of
objects.
The label public:, private : (and protected: as well
shall see in future) are use to control access to a
class’ data members and functions
• Private class members can be access only by
member of that class.

Ct’d
Public members may be access by any function in the
program
The default access mode for classes is private: After each
label, the mode that was invoked by that label applies until
the next label or until the end of class declaration.
The primary purpose of public members is to present to the
class’s clients a view of the services the class provides. This
set of services forms the publics interface of the class
The private members are not accessible to the
clients of a class. They form the implementation of
the class

x
y
Void
move
(int, int )
Void
print
Bool
is_zero
Point.move(100,45)
Interface
Public members
If(point.is_zero())
Implementation
Private members
Point1.print()
messages
*

example
• We modify the move function of the class point clients of
this class can not move a point outside a window with a
size of 500x300.
class point { //point class
int x,y; // private members: x and y coordinates
public: // public members
bool move(int,int); //A function to move the points
void print(); // to print the coordinates on the screen
bool is_zero(); // is the point on the zero point (0,0)
};

Ct’d
// a function to move thepoint (0,500x0,300)
Bool point:: move (int new_x, int new_y)
{
if (new_x>0 && new_x< 500 && // if new_x is in 0-500
new_y > 0 && new_y <300) // if new_y is in 0-300
{
x =new_x; // assigns new value to x coordinate
y = new_y; // assigns new value to y coordinate
return true; // input values are accepted
}
return false; // input values are not accepted
}

Ct’d
The new move function returns a boolean value to inform
the client programmer whether the input values are
accepted or not.
Here is the main fnction:
Int main()
{
point p1; // p1 object is defined
int x’y; // Two variables to read some values from
the keyboard
Cout << “Give x and y coordinates”;
cin>>x>>y; // read two values from the keyboard

Ct’d
if (p1.move(x,y) // send move message and check the result
p1.print(); // if result is OK print coordinates on the screen
else
cout <<“nInput values are not accepted”;
}
it is not possible to assign a value to x or y directly outside the class
p1.x = -10; // ERROR! X is private
Struct keyword in c++:
Class and struct keywords have very similar meaning in the c++. They
both are used to build object models. The only difference is their
default access mode
The default access mode for class is private and
The default access mode for struct is public

Friend Functions and Friend Classes
A function or an entire class may be declared to be a friend of
another class.
A friend of a class has the right to access all members
(private, protected or public) of the class.
Class A{
friend class B; // class B is a friend of class A
Private: // public members of A
Int I;
float f;
public: // public members of A
void func1(char*c);
};

Ct’d
Class B{ // class B
int j;
public:
void
func2(A&s){cout<<s.i;} // B can access private members of A
};
Int main() {
A ObjA;
BobjB;
objB.function2(objA);
return 0;
NB here A is NOT a friend of B. A can not access private members of B

Ct’d
A friend function has right to access all members (private,
protected or public) of the class
class point { // point class
friend void zero (point &); // A friend function of point
int x,y; // private members: x, y coordinates
public: // public members
bool move(int, int); // A function to move the points
void print() // to print the coordinates on the screen
bol is_zero(); // is the point on the zero point(0,0)
},

Ct’d
// Sssigns zero to all coordinates
Void zero(print &p) // Not a member of any class
{
p.x = 0; // assign zero to x of p
p.y = 0; // assign zero to y of p
}

This pointer
Each object has its own data space in the memory of the
computer. When an object is defined, memory is allocated
only for its data members.
The code of member functions are created only once. Each
object of the same class uses the same function code.
point1
point2
X = 100
Y = 50
X =200
Y = 300
move
print
Is_zero

Ct’d
How does c++ ensure that the proper object is
referenced?
C++ compiler maintains a pointer , called the this
pointer
A c++ compiler defines an object pointer this . When a
member function is called, this pointer contains the
address of the object, for which the function is
involked.
so member functions can access the data members
using the pointer this.

Major terminologies in oop (Lect 2).ppt. Object oriented programming

Recommended

More Related Content

Similar to Major terminologies in oop (Lect 2).ppt. Object oriented programming (20)

Recently uploaded (20)

Major terminologies in oop (Lect 2).ppt. Object oriented programming

Editor's Notes