Lecture 12


 In this example, we have a class vector in which the data members
have been put in the public part.
 class vector {
public:
float x;
float y;
vector (float x, float y);
float getX();
float getY();
float getMagnitude();
float getAngle();
};
Coupling Example


Coupling Example
 Now let us assume that we want to write a function to
calculate dot product of two vectors. We write the
following function.
 float myDotProduct1(vector a, vector b)
{
float temp1 = a.getX() * b.getX();
float temp2 = a.getY() * b.getY();
return temp1 + temp2;
}


 Since the data members are public, one could be enticed
to use these members directly (presumably saving some
function calls overhead) and rewrite the same function as
follows:
 float myDotProduct2(vector a, vector b)
{
float temp1 = a.x * b.x;
float temp2 = a.y * b.y;
return temp1 + temp2;
}
Coupling Example

 So far, there does not seem to be any issue. But the scenario changes as soon as there
are changes in the class implementation. Now let us assume that for some reason the
class designer changes the implementation and data structure and decides to stores
the angle and magnitude instead of the x and y components of the vector. The new
class looks like as follows:
 class vector {
public:
float magnitude;
float angle;
vector (float x, float y);
vector (float magnitude, float angle);
float getX();
float getY();
float getMagnitude();
float getAngle();
};
Coupling Example


 Now we see the difference in the two
implementations of the dot product function written
by the user of this class. In the first case, as the dot
product function is dependent upon the public
interface of the vector class, there will be no change
while in the second case the function will have to be
rewritten. This is because in the first case the system
was loosely coupled while in the second case there
was more dependency on the internal structure of
the vector class and hence there was more coupling.
Coupling Example

 class book {
Private:
int bookId;
string ISBN;
string author;
string title;
string publisher;
date yearOfPublication;
int borrowerId;
string borrowersName;
string borrowersAddress;
date IssueDate;
date dueDate;
public:
// member functions
};
Cohesion Example


 The Book class shown above represents a book entity
that contains the attributes and behavior of a specific
book information. It is easy to see that this contains
information about the book as well as the borrower
which is a distinct entity. Hence it is not a cohesive
class and must be broken down into two separate
classes.
Cohesion Example


 This diagram depicts two systems, one with high
coupling and the other one with low coupling. The
lines depict linkages between different components.
In the case of highly coupled system, module
boundaries are not well defined, as everything seems
to be connected with everything else. On the other
hand, in the system with low coupling modules can
be identified easily. In this case intra component
linkages are stronger while inter component linkages
are weak.
Cohesion vs Coupling


 As mentioned earlier, strong cohesion implies that
all parts of a component should have a close logical
relationship with each other. That means, in case
some kind of change is required in the software, all
the related pieces are found at one place. A class will
be cohesive if most of the methods defined in a class
use most of the data members most of the time. If we
find different subsets of data within the same class
being manipulated by separate groups of functions
then the class is not cohesive and should be broken
down as shown in the previous slide.
Cohesion


 Abstractions is a technique in which we construct a
model of an entity based upon its essential
characteristics and ignore the inessential details. The
principle of abstraction also helps us in handling the
inherent complexity of a system by allowing us to
look at its important external characteristic, at the
same time, hiding its inner complexity. Hiding the
internal details is called encapsulation.
Abstraction & Encapsulation


 void selectionSort(int a[], int N)
{
int i, j, min, temp;
for (i=0; i < N-1; i++)
{
min = i;
for (j = i; j< N; j++)
if (a[j] < a[min]) min = j;
temp = a[i];
a[i] = a[min];
a[min] = temp;
}
}
Encapsulation Example


 This function can be rewritten by abstracting out some of
the logical steps into auxiliary functions. The new code is
as follows.
 int minimum (int a[], int from, int to)
{
int min = from;
for (int i=from; i <= to; i++)
if (a[i] < a[min]) min = i;
return min;
}


 void selectionSort (int a[], int N)
{
for (i=0; i<N-1; i++)
{
min = minimum (a, i, N-1);
swap (a[i], a[min]);
}
}


 In this function we have abstracted out two logical steps
performed in this functions. These functions are finding
the index of the minimum value in the given range in an
array and swapping the minimum value with the value at
the ith index in the array. It is easy to see that the
resultant new function is easier to understand than the
previous version of the selection sort function. In the
process, as a by-product, we have created two auxiliary
function mentioned above, which are general in nature
and hence can be used elsewhere as well. Principle of
abstraction thus generates reusable self-contained
components.


In the case of function-oriented approach, data is decomposed
according to functionality requirements. That is, decomposition
revolves around function. In the OO approach, decomposition of a
problem revolves around data. Function-oriented paradigm
focuses only on the functionality of a system and typically ignores
the data until it is required. Object- oriented paradigm focuses
both on the functionality and the data at the same time. The basic
difference between these two is decentralized control mechanism
versus centralized control mechanism respectively.
Decentralization gives OO the ability to handle essential
complexity better than function-oriented approach.
Function Oriented vs Object Oriented Design


 In this diagram, the ovals depict the function while
rectangles/squares depict data. Since a function contains
dynamic information while data contains only static
information, if the function and data are managed separately,
the required data components can be found by scanning a
function but the functions that use a particular data cannot be
found by just looking at the data. That is, the function knows
about the data it needs to use but the data do not know about
the functions using it. That means it is easy to make a change in
a function since we would know which data components
would be affected by this change. On the other hand, changing
a data structure would be more difficult because it would not
be easy to find all the functions that are using this data and
hence also need to be modified.
Function Oriented Design

Lecture 12

More Related Content

What's hot (20)

Viewers also liked (19)

Similar to Lecture 12 (20)

Lecture 12